diff options
Diffstat (limited to 'build/generated/source/proto/main/cpp/messages')
4 files changed, 4323 insertions, 23 deletions
diff --git a/build/generated/source/proto/main/cpp/messages/VehiclePrecisionLocation.pb.cc b/build/generated/source/proto/main/cpp/messages/VehiclePrecisionLocation.pb.cc index c0fdc1c..e77684c 100644 --- a/build/generated/source/proto/main/cpp/messages/VehiclePrecisionLocation.pb.cc +++ b/build/generated/source/proto/main/cpp/messages/VehiclePrecisionLocation.pb.cc @@ -35,7 +35,10 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RequestCurrentVehicleLocationDefaultTypeInternal _RequestCurrentVehicleLocation_default_instance_; PROTOBUF_CONSTEXPR ResponseCurrentVehicleLocation::ResponseCurrentVehicleLocation( ::_pbi::ConstantInitialized): _impl_{ - /*decltype(_impl_.vehiclecurrentlocation_)*/nullptr + /*decltype(_impl_.vehiclemessageheading_)*/nullptr + , /*decltype(_impl_.vehiclecurrentlocation_)*/nullptr + , /*decltype(_impl_.responsestatus_)*/ 0 + , /*decltype(_impl_._cached_size_)*/{}} {} struct ResponseCurrentVehicleLocationDefaultTypeInternal { PROTOBUF_CONSTEXPR ResponseCurrentVehicleLocationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} @@ -47,10 +50,24 @@ struct ResponseCurrentVehicleLocationDefaultTypeInternal { 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_; } // namespace messages -static ::_pb::Metadata file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto[2]; -static constexpr const ::_pb::EnumDescriptor** - file_level_enum_descriptors_messages_2fVehiclePrecisionLocation_2eproto = nullptr; +static ::_pb::Metadata file_level_metadata_messages_2fVehiclePrecisionLocation_2eproto[3]; +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( @@ -72,43 +89,68 @@ const ::uint32_t TableStruct_messages_2fVehiclePrecisionLocation_2eproto::offset ~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_), }; static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, -1, sizeof(::messages::RequestCurrentVehicleLocation)}, { 9, -1, -1, sizeof(::messages::ResponseCurrentVehicleLocation)}, + { 20, -1, -1, sizeof(::messages::PublishCurrentVehicleLocation)}, }; static const ::_pb::Message* const file_default_instances[] = { &::messages::_RequestCurrentVehicleLocation_default_instance_._instance, &::messages::_ResponseCurrentVehicleLocation_default_instance_._instance, + &::messages::_PublishCurrentVehicleLocation_default_instance_._instance, }; const char descriptor_table_protodef_messages_2fVehiclePrecisionLocation_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { "\n\'messages/VehiclePrecisionLocation.prot" - "o\022\010messages\032\017vss/vspec.proto\"a\n\035RequestC" - "urrentVehicleLocation\022@\n\025vehicleIdentifi" - "cation\030\001 \001(\0132!.vss.VehicleVehicleIdentif" - "ication\"]\n\036ResponseCurrentVehicleLocatio" - "n\022;\n\026vehicleCurrentLocation\030\001 \001(\0132\033.vss." - "VehicleCurrentLocationb\006proto3" + "o\022\010messages\032\017vss/vspec.proto\032#messages/V" + "ehicleMessageHeader.proto\"a\n\035RequestCurr" + "entVehicleLocation\022@\n\025vehicleIdentificat" + "ion\030\001 \001(\0132!.vss.VehicleVehicleIdentifica" + "tion\"\323\001\n\036ResponseCurrentVehicleLocation\022" + ">\n\025vehicleMessageHeading\030\001 \001(\0132\037.message" + "s.VehicleMessageHeading\022;\n\026vehicleCurren" + "tLocation\030\002 \001(\0132\033.vss.VehicleCurrentLoca" + "tion\0224\n\016responseStatus\030\003 \001(\0162\034.messages." + "ResponseStatusEnum\"\234\001\n\035PublishCurrentVeh" + "icleLocation\022>\n\025vehicleMessageHeading\030\001 " + "\001(\0132\037.messages.VehicleMessageHeading\022;\n\026" + "vehicleCurrentLocation\030\002 \001(\0132\033.vss.Vehic" + "leCurrentLocation*S\n\022ResponseStatusEnum\022" + "\013\n\007SUCCESS\020\000\022\024\n\020FAIL_NO_RESPONSE\020\001\022\032\n\026FA" + "IL_DEGRADED_RESPONSE\020\002b\006proto3" }; -static const ::_pbi::DescriptorTable* const descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_deps[1] = +static const ::_pbi::DescriptorTable* const descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_deps[2] = { + &::descriptor_table_messages_2fVehicleMessageHeader_2eproto, &::descriptor_table_vss_2fvspec_2eproto, }; static ::absl::once_flag descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_messages_2fVehiclePrecisionLocation_2eproto = { false, false, - 270, + 670, descriptor_table_protodef_messages_2fVehiclePrecisionLocation_2eproto, "messages/VehiclePrecisionLocation.proto", &descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_once, descriptor_table_messages_2fVehiclePrecisionLocation_2eproto_deps, - 1, 2, + 3, schemas, file_default_instances, TableStruct_messages_2fVehiclePrecisionLocation_2eproto::offsets, @@ -135,6 +177,20 @@ PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_messages 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 RequestCurrentVehicleLocation::_Internal { @@ -335,13 +391,24 @@ void RequestCurrentVehicleLocation::InternalSwap(RequestCurrentVehicleLocation* class ResponseCurrentVehicleLocation::_Internal { public: + static const ::messages::VehicleMessageHeading& vehiclemessageheading(const ResponseCurrentVehicleLocation* msg); static const ::vss::VehicleCurrentLocation& vehiclecurrentlocation(const ResponseCurrentVehicleLocation* msg); }; +const ::messages::VehicleMessageHeading& +ResponseCurrentVehicleLocation::_Internal::vehiclemessageheading(const ResponseCurrentVehicleLocation* msg) { + return *msg->_impl_.vehiclemessageheading_; +} const ::vss::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; +} void ResponseCurrentVehicleLocation::clear_vehiclecurrentlocation() { if (GetArenaForAllocation() == nullptr && _impl_.vehiclecurrentlocation_ != nullptr) { delete _impl_.vehiclecurrentlocation_; @@ -357,20 +424,30 @@ ResponseCurrentVehicleLocation::ResponseCurrentVehicleLocation(const ResponseCur : ::PROTOBUF_NAMESPACE_ID::Message() { ResponseCurrentVehicleLocation* const _this = this; (void)_this; new (&_impl_) Impl_{ - decltype(_impl_.vehiclecurrentlocation_){nullptr} + 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 ::vss::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_.vehiclecurrentlocation_){nullptr} + decltype(_impl_.vehiclemessageheading_){nullptr} + , decltype(_impl_.vehiclecurrentlocation_){nullptr} + , decltype(_impl_.responsestatus_) { 0 } + , /*decltype(_impl_._cached_size_)*/{} }; } @@ -386,6 +463,7 @@ ResponseCurrentVehicleLocation::~ResponseCurrentVehicleLocation() { inline void ResponseCurrentVehicleLocation::SharedDtor() { ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.vehiclemessageheading_; if (this != internal_default_instance()) delete _impl_.vehiclecurrentlocation_; } @@ -399,10 +477,15 @@ void ResponseCurrentVehicleLocation::Clear() { // 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>(); } @@ -412,15 +495,34 @@ const char* ResponseCurrentVehicleLocation::_InternalParse(const char* ptr, ::_p ::uint32_t tag; ptr = ::_pbi::ReadTag(ptr, &tag); switch (tag >> 3) { - // .vss.VehicleCurrentLocation vehicleCurrentLocation = 1; + // .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; + // .vss.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 @@ -450,13 +552,27 @@ failure: ::uint32_t cached_has_bits = 0; (void) cached_has_bits; - // .vss.VehicleCurrentLocation vehicleCurrentLocation = 1; + // .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); + } + + // .vss.VehicleCurrentLocation vehicleCurrentLocation = 2; if (this->_internal_has_vehiclecurrentlocation()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, _Internal::vehiclecurrentlocation(this), + 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); @@ -473,13 +589,26 @@ failure: // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .vss.VehicleCurrentLocation vehicleCurrentLocation = 1; + // .messages.VehicleMessageHeading vehicleMessageHeading = 1; + if (this->_internal_has_vehiclemessageheading()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.vehiclemessageheading_); + } + + // .vss.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_); } @@ -498,10 +627,17 @@ void ResponseCurrentVehicleLocation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& ::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()->::vss::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_); } @@ -519,7 +655,12 @@ bool ResponseCurrentVehicleLocation::IsInitialized() const { void ResponseCurrentVehicleLocation::InternalSwap(ResponseCurrentVehicleLocation* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.vehiclecurrentlocation_, other->_impl_.vehiclecurrentlocation_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ResponseCurrentVehicleLocation, _impl_.responsestatus_) + + sizeof(ResponseCurrentVehicleLocation::_impl_.responsestatus_) + - PROTOBUF_FIELD_OFFSET(ResponseCurrentVehicleLocation, _impl_.vehiclemessageheading_)>( + reinterpret_cast<char*>(&_impl_.vehiclemessageheading_), + reinterpret_cast<char*>(&other->_impl_.vehiclemessageheading_)); } ::PROTOBUF_NAMESPACE_ID::Metadata ResponseCurrentVehicleLocation::GetMetadata() const { @@ -527,6 +668,255 @@ void ResponseCurrentVehicleLocation::InternalSwap(ResponseCurrentVehicleLocation &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 ::vss::VehicleCurrentLocation& vehiclecurrentlocation(const PublishCurrentVehicleLocation* msg); +}; + +const ::messages::VehicleMessageHeading& +PublishCurrentVehicleLocation::_Internal::vehiclemessageheading(const PublishCurrentVehicleLocation* msg) { + return *msg->_impl_.vehiclemessageheading_; +} +const ::vss::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; +} +void PublishCurrentVehicleLocation::clear_vehiclecurrentlocation() { + if (GetArenaForAllocation() == nullptr && _impl_.vehiclecurrentlocation_ != nullptr) { + delete _impl_.vehiclecurrentlocation_; + } + _impl_.vehiclecurrentlocation_ = 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 ::vss::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; + // .vss.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); + } + + // .vss.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_); + } + + // .vss.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<PublishCurrentVehicleLocation*>(&to_msg); + auto& from = static_cast<const PublishCurrentVehicleLocation&>(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()->::vss::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<char*>(&_impl_.vehiclemessageheading_), + reinterpret_cast<char*>(&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]); +} // @@protoc_insertion_point(namespace_scope) } // namespace messages PROTOBUF_NAMESPACE_OPEN @@ -538,6 +928,10 @@ 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); +} PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" diff --git a/build/generated/source/proto/main/cpp/messages/VehiclePrecisionLocation.pb.h b/build/generated/source/proto/main/cpp/messages/VehiclePrecisionLocation.pb.h index 7ea08e7..88a1a49 100644 --- a/build/generated/source/proto/main/cpp/messages/VehiclePrecisionLocation.pb.h +++ b/build/generated/source/proto/main/cpp/messages/VehiclePrecisionLocation.pb.h @@ -30,8 +30,10 @@ #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 "vss/vspec.pb.h" +#include "messages/VehicleMessageHeader.pb.h" // @@protoc_insertion_point(includes) // Must be included last. @@ -52,6 +54,9 @@ struct TableStruct_messages_2fVehiclePrecisionLocation_2eproto { extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_messages_2fVehiclePrecisionLocation_2eproto; namespace messages { +class PublishCurrentVehicleLocation; +struct PublishCurrentVehicleLocationDefaultTypeInternal; +extern PublishCurrentVehicleLocationDefaultTypeInternal _PublishCurrentVehicleLocation_default_instance_; class RequestCurrentVehicleLocation; struct RequestCurrentVehicleLocationDefaultTypeInternal; extern RequestCurrentVehicleLocationDefaultTypeInternal _RequestCurrentVehicleLocation_default_instance_; @@ -61,12 +66,47 @@ extern ResponseCurrentVehicleLocationDefaultTypeInternal _ResponseCurrentVehicle } // namespace messages PROTOBUF_NAMESPACE_OPEN template <> +::messages::PublishCurrentVehicleLocation* Arena::CreateMaybeMessage<::messages::PublishCurrentVehicleLocation>(Arena*); +template <> ::messages::RequestCurrentVehicleLocation* Arena::CreateMaybeMessage<::messages::RequestCurrentVehicleLocation>(Arena*); template <> ::messages::ResponseCurrentVehicleLocation* Arena::CreateMaybeMessage<::messages::ResponseCurrentVehicleLocation>(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<ResponseStatusEnum>(0); +constexpr ResponseStatusEnum ResponseStatusEnum_MAX = static_cast<ResponseStatusEnum>(2); +constexpr int ResponseStatusEnum_ARRAYSIZE = 2 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +ResponseStatusEnum_descriptor(); +template <typename T> +const std::string& ResponseStatusEnum_Name(T value) { + static_assert(std::is_same<T, ResponseStatusEnum>::value || + std::is_integral<T>::value, + "Incorrect type passed to ResponseStatusEnum_Name()."); + return ResponseStatusEnum_Name(static_cast<ResponseStatusEnum>(value)); +} +template <> +inline const std::string& ResponseStatusEnum_Name(ResponseStatusEnum value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<ResponseStatusEnum_descriptor, + 0, 2>( + static_cast<int>(value)); +} +inline bool ResponseStatusEnum_Parse(absl::string_view name, ResponseStatusEnum* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ResponseStatusEnum>( + ResponseStatusEnum_descriptor(), name, value); +} // =================================================================== @@ -348,9 +388,29 @@ class ResponseCurrentVehicleLocation final : // accessors ------------------------------------------------------- enum : int { - kVehicleCurrentLocationFieldNumber = 1, + kVehicleMessageHeadingFieldNumber = 1, + kVehicleCurrentLocationFieldNumber = 2, + kResponseStatusFieldNumber = 3, }; - // .vss.VehicleCurrentLocation vehicleCurrentLocation = 1; + // .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(); + // .vss.VehicleCurrentLocation vehicleCurrentLocation = 2; bool has_vehiclecurrentlocation() const; private: bool _internal_has_vehiclecurrentlocation() const; @@ -368,6 +428,16 @@ class ResponseCurrentVehicleLocation final : void unsafe_arena_set_allocated_vehiclecurrentlocation( ::vss::VehicleCurrentLocation* vehiclecurrentlocation); ::vss::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; @@ -376,6 +446,183 @@ class ResponseCurrentVehicleLocation final : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { + ::messages::VehicleMessageHeading* vehiclemessageheading_; + ::vss::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<const PublishCurrentVehicleLocation*>( + &_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<PublishCurrentVehicleLocation>(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(); + // .vss.VehicleCurrentLocation vehicleCurrentLocation = 2; + bool has_vehiclecurrentlocation() const; + private: + bool _internal_has_vehiclecurrentlocation() const; + + public: + void clear_vehiclecurrentlocation() ; + const ::vss::VehicleCurrentLocation& vehiclecurrentlocation() const; + PROTOBUF_NODISCARD ::vss::VehicleCurrentLocation* release_vehiclecurrentlocation(); + ::vss::VehicleCurrentLocation* mutable_vehiclecurrentlocation(); + void set_allocated_vehiclecurrentlocation(::vss::VehicleCurrentLocation* vehiclecurrentlocation); + private: + const ::vss::VehicleCurrentLocation& _internal_vehiclecurrentlocation() const; + ::vss::VehicleCurrentLocation* _internal_mutable_vehiclecurrentlocation(); + public: + void unsafe_arena_set_allocated_vehiclecurrentlocation( + ::vss::VehicleCurrentLocation* vehiclecurrentlocation); + ::vss::VehicleCurrentLocation* unsafe_arena_release_vehiclecurrentlocation(); + // @@protoc_insertion_point(class_scope:messages.PublishCurrentVehicleLocation) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::messages::VehicleMessageHeading* vehiclemessageheading_; ::vss::VehicleCurrentLocation* vehiclecurrentlocation_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; @@ -483,7 +730,87 @@ inline void RequestCurrentVehicleLocation::set_allocated_vehicleidentification(: // ResponseCurrentVehicleLocation -// .vss.VehicleCurrentLocation vehicleCurrentLocation = 1; +// .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<const ::messages::VehicleMessageHeading&>( + ::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) +} + +// .vss.VehicleCurrentLocation vehicleCurrentLocation = 2; inline bool ResponseCurrentVehicleLocation::_internal_has_vehiclecurrentlocation() const { return this != internal_default_instance() && _impl_.vehiclecurrentlocation_ != nullptr; } @@ -563,6 +890,190 @@ inline void ResponseCurrentVehicleLocation::set_allocated_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<const ::messages::VehicleMessageHeading&>( + ::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) +} + +// .vss.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 const ::vss::VehicleCurrentLocation& PublishCurrentVehicleLocation::_internal_vehiclecurrentlocation() const { + const ::vss::VehicleCurrentLocation* p = _impl_.vehiclecurrentlocation_; + return p != nullptr ? *p : reinterpret_cast<const ::vss::VehicleCurrentLocation&>( + ::vss::_VehicleCurrentLocation_default_instance_); +} +inline const ::vss::VehicleCurrentLocation& PublishCurrentVehicleLocation::vehiclecurrentlocation() const { + // @@protoc_insertion_point(field_get:messages.PublishCurrentVehicleLocation.vehicleCurrentLocation) + return _internal_vehiclecurrentlocation(); +} +inline void PublishCurrentVehicleLocation::unsafe_arena_set_allocated_vehiclecurrentlocation( + ::vss::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 ::vss::VehicleCurrentLocation* PublishCurrentVehicleLocation::release_vehiclecurrentlocation() { + + ::vss::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 ::vss::VehicleCurrentLocation* PublishCurrentVehicleLocation::unsafe_arena_release_vehiclecurrentlocation() { + // @@protoc_insertion_point(field_release:messages.PublishCurrentVehicleLocation.vehicleCurrentLocation) + + ::vss::VehicleCurrentLocation* temp = _impl_.vehiclecurrentlocation_; + _impl_.vehiclecurrentlocation_ = nullptr; + return temp; +} +inline ::vss::VehicleCurrentLocation* PublishCurrentVehicleLocation::_internal_mutable_vehiclecurrentlocation() { + + if (_impl_.vehiclecurrentlocation_ == nullptr) { + auto* p = CreateMaybeMessage<::vss::VehicleCurrentLocation>(GetArenaForAllocation()); + _impl_.vehiclecurrentlocation_ = p; + } + return _impl_.vehiclecurrentlocation_; +} +inline ::vss::VehicleCurrentLocation* PublishCurrentVehicleLocation::mutable_vehiclecurrentlocation() { + ::vss::VehicleCurrentLocation* _msg = _internal_mutable_vehiclecurrentlocation(); + // @@protoc_insertion_point(field_mutable:messages.PublishCurrentVehicleLocation.vehicleCurrentLocation) + return _msg; +} +inline void PublishCurrentVehicleLocation::set_allocated_vehiclecurrentlocation(::vss::VehicleCurrentLocation* vehiclecurrentlocation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.vehiclecurrentlocation_); + } + if (vehiclecurrentlocation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(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) +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -571,6 +1082,17 @@ inline void ResponseCurrentVehicleLocation::set_allocated_vehiclecurrentlocation } // 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" diff --git a/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.cc b/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.cc new file mode 100644 index 0000000..894932e --- /dev/null +++ b/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.cc @@ -0,0 +1,1598 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: messages/VehicleRemoteHvac.proto + +#include "messages/VehicleRemoteHvac.pb.h" + +#include <algorithm> +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/generated_message_reflection.h" +#include "google/protobuf/reflection_ops.h" +#include "google/protobuf/wire_format.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::PROTOBUF_NAMESPACE_ID; +namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal; +namespace messages { +PROTOBUF_CONSTEXPR CabinPreconditionRequest::CabinPreconditionRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.messageheader_)*/nullptr + , /*decltype(_impl_.setacstatus_)*/nullptr + , /*decltype(_impl_.settemp_)*/nullptr + , /*decltype(_impl_._cached_size_)*/{}} {} +struct CabinPreconditionRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR CabinPreconditionRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CabinPreconditionRequestDefaultTypeInternal() {} + union { + CabinPreconditionRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CabinPreconditionRequestDefaultTypeInternal _CabinPreconditionRequest_default_instance_; +PROTOBUF_CONSTEXPR CabinPreConditionReponse::CabinPreConditionReponse( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.messageheader_)*/nullptr + , /*decltype(_impl_.setacstatusreply_)*/nullptr + , /*decltype(_impl_.settemperaturereply_)*/nullptr + , /*decltype(_impl_._cached_size_)*/{}} {} +struct CabinPreConditionReponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR CabinPreConditionReponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CabinPreConditionReponseDefaultTypeInternal() {} + union { + CabinPreConditionReponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CabinPreConditionReponseDefaultTypeInternal _CabinPreConditionReponse_default_instance_; +PROTOBUF_CONSTEXPR SetAcStatusRequest::SetAcStatusRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.desiredstatus_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct SetAcStatusRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetAcStatusRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetAcStatusRequestDefaultTypeInternal() {} + union { + SetAcStatusRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetAcStatusRequestDefaultTypeInternal _SetAcStatusRequest_default_instance_; +PROTOBUF_CONSTEXPR SetAcStatusReply::SetAcStatusReply( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.status_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct SetAcStatusReplyDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetAcStatusReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetAcStatusReplyDefaultTypeInternal() {} + union { + SetAcStatusReply _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetAcStatusReplyDefaultTypeInternal _SetAcStatusReply_default_instance_; +PROTOBUF_CONSTEXPR SetTemperatureRequest::SetTemperatureRequest( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.temperature_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct SetTemperatureRequestDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetTemperatureRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetTemperatureRequestDefaultTypeInternal() {} + union { + SetTemperatureRequest _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetTemperatureRequestDefaultTypeInternal _SetTemperatureRequest_default_instance_; +PROTOBUF_CONSTEXPR SetTemperatureReply::SetTemperatureReply( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.tempstatus_)*/ 0 + + , /*decltype(_impl_._cached_size_)*/{}} {} +struct SetTemperatureReplyDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetTemperatureReplyDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetTemperatureReplyDefaultTypeInternal() {} + union { + SetTemperatureReply _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetTemperatureReplyDefaultTypeInternal _SetTemperatureReply_default_instance_; +} // namespace messages +static ::_pb::Metadata file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[6]; +static const ::_pb::EnumDescriptor* file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[2]; +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::CabinPreconditionRequest, _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::CabinPreconditionRequest, _impl_.messageheader_), + PROTOBUF_FIELD_OFFSET(::messages::CabinPreconditionRequest, _impl_.setacstatus_), + PROTOBUF_FIELD_OFFSET(::messages::CabinPreconditionRequest, _impl_.settemp_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::CabinPreConditionReponse, _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::CabinPreConditionReponse, _impl_.messageheader_), + PROTOBUF_FIELD_OFFSET(::messages::CabinPreConditionReponse, _impl_.setacstatusreply_), + PROTOBUF_FIELD_OFFSET(::messages::CabinPreConditionReponse, _impl_.settemperaturereply_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::SetAcStatusRequest, _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::SetAcStatusRequest, _impl_.desiredstatus_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::SetAcStatusReply, _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::SetAcStatusReply, _impl_.status_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::SetTemperatureRequest, _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::SetTemperatureRequest, _impl_.temperature_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::messages::SetTemperatureReply, _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::SetTemperatureReply, _impl_.tempstatus_), +}; + +static const ::_pbi::MigrationSchema + schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, -1, sizeof(::messages::CabinPreconditionRequest)}, + { 11, -1, -1, sizeof(::messages::CabinPreConditionReponse)}, + { 22, -1, -1, sizeof(::messages::SetAcStatusRequest)}, + { 31, -1, -1, sizeof(::messages::SetAcStatusReply)}, + { 40, -1, -1, sizeof(::messages::SetTemperatureRequest)}, + { 49, -1, -1, sizeof(::messages::SetTemperatureReply)}, +}; + +static const ::_pb::Message* const file_default_instances[] = { + &::messages::_CabinPreconditionRequest_default_instance_._instance, + &::messages::_CabinPreConditionReponse_default_instance_._instance, + &::messages::_SetAcStatusRequest_default_instance_._instance, + &::messages::_SetAcStatusReply_default_instance_._instance, + &::messages::_SetTemperatureRequest_default_instance_._instance, + &::messages::_SetTemperatureReply_default_instance_._instance, +}; +const char descriptor_table_protodef_messages_2fVehicleRemoteHvac_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + "\n messages/VehicleRemoteHvac.proto\022\010mess" + "ages\032\017vss/vspec.proto\032#messages/VehicleM" + "essageHeader.proto\"\267\001\n\030CabinPrecondition" + "Request\0226\n\rmessageHeader\030\001 \001(\0132\037.message" + "s.VehicleMessageHeading\0221\n\013setAcStatus\030\002" + " \001(\0132\034.messages.SetAcStatusRequest\0220\n\007se" + "tTemp\030\003 \001(\0132\037.messages.SetTemperatureReq" + "uest\"\304\001\n\030CabinPreConditionReponse\0226\n\rmes" + "sageHeader\030\001 \001(\0132\037.messages.VehicleMessa" + "geHeading\0224\n\020setAcStatusReply\030\002 \001(\0132\032.me" + "ssages.SetAcStatusReply\022:\n\023setTemperatur" + "eReply\030\003 \001(\0132\035.messages.SetTemperatureRe" + "ply\"C\n\022SetAcStatusRequest\022-\n\rdesiredStat" + "us\030\001 \001(\0162\026.messages.AcStatusEnum\":\n\020SetA" + "cStatusReply\022&\n\006status\030\001 \001(\0162\026.messages." + "AcStatusEnum\",\n\025SetTemperatureRequest\022\023\n" + "\013temperature\030\001 \001(\002\"F\n\023SetTemperatureRepl" + "y\022/\n\ntempStatus\030\001 \001(\0162\033.messages.SetTemp" + "StatusEnum*2\n\014AcStatusEnum\022\006\n\002ON\020\000\022\007\n\003OF" + "F\020\001\022\021\n\rUKNONWN_ERROR\020\002*5\n\021SetTempStatusE" + "num\022\020\n\014TEMP_SUCCESS\020\000\022\016\n\nTEMP_ERROR\020\001b\006p" + "roto3" +}; +static const ::_pbi::DescriptorTable* const descriptor_table_messages_2fVehicleRemoteHvac_2eproto_deps[2] = + { + &::descriptor_table_messages_2fVehicleMessageHeader_2eproto, + &::descriptor_table_vss_2fvspec_2eproto, +}; +static ::absl::once_flag descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once; +const ::_pbi::DescriptorTable descriptor_table_messages_2fVehicleRemoteHvac_2eproto = { + false, + false, + 845, + descriptor_table_protodef_messages_2fVehicleRemoteHvac_2eproto, + "messages/VehicleRemoteHvac.proto", + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + descriptor_table_messages_2fVehicleRemoteHvac_2eproto_deps, + 2, + 6, + 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* AcStatusEnum_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto); + return file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[0]; +} +bool AcStatusEnum_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetTempStatusEnum_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_messages_2fVehicleRemoteHvac_2eproto); + return file_level_enum_descriptors_messages_2fVehicleRemoteHvac_2eproto[1]; +} +bool SetTempStatusEnum_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} +// =================================================================== + +class CabinPreconditionRequest::_Internal { + public: + static const ::messages::VehicleMessageHeading& messageheader(const CabinPreconditionRequest* msg); + static const ::messages::SetAcStatusRequest& setacstatus(const CabinPreconditionRequest* msg); + static const ::messages::SetTemperatureRequest& settemp(const CabinPreconditionRequest* msg); +}; + +const ::messages::VehicleMessageHeading& +CabinPreconditionRequest::_Internal::messageheader(const CabinPreconditionRequest* msg) { + return *msg->_impl_.messageheader_; +} +const ::messages::SetAcStatusRequest& +CabinPreconditionRequest::_Internal::setacstatus(const CabinPreconditionRequest* msg) { + return *msg->_impl_.setacstatus_; +} +const ::messages::SetTemperatureRequest& +CabinPreconditionRequest::_Internal::settemp(const CabinPreconditionRequest* msg) { + return *msg->_impl_.settemp_; +} +void CabinPreconditionRequest::clear_messageheader() { + if (GetArenaForAllocation() == nullptr && _impl_.messageheader_ != nullptr) { + delete _impl_.messageheader_; + } + _impl_.messageheader_ = nullptr; +} +CabinPreconditionRequest::CabinPreconditionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.CabinPreconditionRequest) +} +CabinPreconditionRequest::CabinPreconditionRequest(const CabinPreconditionRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + CabinPreconditionRequest* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.messageheader_){nullptr} + , decltype(_impl_.setacstatus_){nullptr} + , decltype(_impl_.settemp_){nullptr} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_messageheader()) { + _this->_impl_.messageheader_ = new ::messages::VehicleMessageHeading(*from._impl_.messageheader_); + } + if (from._internal_has_setacstatus()) { + _this->_impl_.setacstatus_ = new ::messages::SetAcStatusRequest(*from._impl_.setacstatus_); + } + if (from._internal_has_settemp()) { + _this->_impl_.settemp_ = new ::messages::SetTemperatureRequest(*from._impl_.settemp_); + } + // @@protoc_insertion_point(copy_constructor:messages.CabinPreconditionRequest) +} + +inline void CabinPreconditionRequest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.messageheader_){nullptr} + , decltype(_impl_.setacstatus_){nullptr} + , decltype(_impl_.settemp_){nullptr} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +CabinPreconditionRequest::~CabinPreconditionRequest() { + // @@protoc_insertion_point(destructor:messages.CabinPreconditionRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void CabinPreconditionRequest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.messageheader_; + if (this != internal_default_instance()) delete _impl_.setacstatus_; + if (this != internal_default_instance()) delete _impl_.settemp_; +} + +void CabinPreconditionRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void CabinPreconditionRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.CabinPreconditionRequest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaForAllocation() == nullptr && _impl_.messageheader_ != nullptr) { + delete _impl_.messageheader_; + } + _impl_.messageheader_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.setacstatus_ != nullptr) { + delete _impl_.setacstatus_; + } + _impl_.setacstatus_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.settemp_ != nullptr) { + delete _impl_.settemp_; + } + _impl_.settemp_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CabinPreconditionRequest::_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 messageHeader = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_messageheader(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.SetAcStatusRequest setAcStatus = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_setacstatus(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.SetTemperatureRequest setTemp = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_settemp(), 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* CabinPreconditionRequest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.CabinPreconditionRequest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.VehicleMessageHeading messageHeader = 1; + if (this->_internal_has_messageheader()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::messageheader(this), + _Internal::messageheader(this).GetCachedSize(), target, stream); + } + + // .messages.SetAcStatusRequest setAcStatus = 2; + if (this->_internal_has_setacstatus()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::setacstatus(this), + _Internal::setacstatus(this).GetCachedSize(), target, stream); + } + + // .messages.SetTemperatureRequest setTemp = 3; + if (this->_internal_has_settemp()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::settemp(this), + _Internal::settemp(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.CabinPreconditionRequest) + return target; +} + +::size_t CabinPreconditionRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.CabinPreconditionRequest) + ::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 messageHeader = 1; + if (this->_internal_has_messageheader()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.messageheader_); + } + + // .messages.SetAcStatusRequest setAcStatus = 2; + if (this->_internal_has_setacstatus()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.setacstatus_); + } + + // .messages.SetTemperatureRequest setTemp = 3; + if (this->_internal_has_settemp()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.settemp_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinPreconditionRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + CabinPreconditionRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinPreconditionRequest::GetClassData() const { return &_class_data_; } + + +void CabinPreconditionRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast<CabinPreconditionRequest*>(&to_msg); + auto& from = static_cast<const CabinPreconditionRequest&>(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.CabinPreconditionRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_messageheader()) { + _this->_internal_mutable_messageheader()->::messages::VehicleMessageHeading::MergeFrom( + from._internal_messageheader()); + } + if (from._internal_has_setacstatus()) { + _this->_internal_mutable_setacstatus()->::messages::SetAcStatusRequest::MergeFrom( + from._internal_setacstatus()); + } + if (from._internal_has_settemp()) { + _this->_internal_mutable_settemp()->::messages::SetTemperatureRequest::MergeFrom( + from._internal_settemp()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CabinPreconditionRequest::CopyFrom(const CabinPreconditionRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.CabinPreconditionRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CabinPreconditionRequest::IsInitialized() const { + return true; +} + +void CabinPreconditionRequest::InternalSwap(CabinPreconditionRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CabinPreconditionRequest, _impl_.settemp_) + + sizeof(CabinPreconditionRequest::_impl_.settemp_) + - PROTOBUF_FIELD_OFFSET(CabinPreconditionRequest, _impl_.messageheader_)>( + reinterpret_cast<char*>(&_impl_.messageheader_), + reinterpret_cast<char*>(&other->_impl_.messageheader_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CabinPreconditionRequest::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 CabinPreConditionReponse::_Internal { + public: + static const ::messages::VehicleMessageHeading& messageheader(const CabinPreConditionReponse* msg); + static const ::messages::SetAcStatusReply& setacstatusreply(const CabinPreConditionReponse* msg); + static const ::messages::SetTemperatureReply& settemperaturereply(const CabinPreConditionReponse* msg); +}; + +const ::messages::VehicleMessageHeading& +CabinPreConditionReponse::_Internal::messageheader(const CabinPreConditionReponse* msg) { + return *msg->_impl_.messageheader_; +} +const ::messages::SetAcStatusReply& +CabinPreConditionReponse::_Internal::setacstatusreply(const CabinPreConditionReponse* msg) { + return *msg->_impl_.setacstatusreply_; +} +const ::messages::SetTemperatureReply& +CabinPreConditionReponse::_Internal::settemperaturereply(const CabinPreConditionReponse* msg) { + return *msg->_impl_.settemperaturereply_; +} +void CabinPreConditionReponse::clear_messageheader() { + if (GetArenaForAllocation() == nullptr && _impl_.messageheader_ != nullptr) { + delete _impl_.messageheader_; + } + _impl_.messageheader_ = nullptr; +} +CabinPreConditionReponse::CabinPreConditionReponse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.CabinPreConditionReponse) +} +CabinPreConditionReponse::CabinPreConditionReponse(const CabinPreConditionReponse& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + CabinPreConditionReponse* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.messageheader_){nullptr} + , decltype(_impl_.setacstatusreply_){nullptr} + , decltype(_impl_.settemperaturereply_){nullptr} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_messageheader()) { + _this->_impl_.messageheader_ = new ::messages::VehicleMessageHeading(*from._impl_.messageheader_); + } + if (from._internal_has_setacstatusreply()) { + _this->_impl_.setacstatusreply_ = new ::messages::SetAcStatusReply(*from._impl_.setacstatusreply_); + } + if (from._internal_has_settemperaturereply()) { + _this->_impl_.settemperaturereply_ = new ::messages::SetTemperatureReply(*from._impl_.settemperaturereply_); + } + // @@protoc_insertion_point(copy_constructor:messages.CabinPreConditionReponse) +} + +inline void CabinPreConditionReponse::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.messageheader_){nullptr} + , decltype(_impl_.setacstatusreply_){nullptr} + , decltype(_impl_.settemperaturereply_){nullptr} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +CabinPreConditionReponse::~CabinPreConditionReponse() { + // @@protoc_insertion_point(destructor:messages.CabinPreConditionReponse) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void CabinPreConditionReponse::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.messageheader_; + if (this != internal_default_instance()) delete _impl_.setacstatusreply_; + if (this != internal_default_instance()) delete _impl_.settemperaturereply_; +} + +void CabinPreConditionReponse::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void CabinPreConditionReponse::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.CabinPreConditionReponse) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaForAllocation() == nullptr && _impl_.messageheader_ != nullptr) { + delete _impl_.messageheader_; + } + _impl_.messageheader_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.setacstatusreply_ != nullptr) { + delete _impl_.setacstatusreply_; + } + _impl_.setacstatusreply_ = nullptr; + if (GetArenaForAllocation() == nullptr && _impl_.settemperaturereply_ != nullptr) { + delete _impl_.settemperaturereply_; + } + _impl_.settemperaturereply_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* CabinPreConditionReponse::_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 messageHeader = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_messageheader(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.SetAcStatusReply setAcStatusReply = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_setacstatusreply(), ptr); + CHK_(ptr); + } else { + goto handle_unusual; + } + continue; + // .messages.SetTemperatureReply setTemperatureReply = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_settemperaturereply(), 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* CabinPreConditionReponse::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.CabinPreConditionReponse) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.VehicleMessageHeading messageHeader = 1; + if (this->_internal_has_messageheader()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::messageheader(this), + _Internal::messageheader(this).GetCachedSize(), target, stream); + } + + // .messages.SetAcStatusReply setAcStatusReply = 2; + if (this->_internal_has_setacstatusreply()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, _Internal::setacstatusreply(this), + _Internal::setacstatusreply(this).GetCachedSize(), target, stream); + } + + // .messages.SetTemperatureReply setTemperatureReply = 3; + if (this->_internal_has_settemperaturereply()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::settemperaturereply(this), + _Internal::settemperaturereply(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.CabinPreConditionReponse) + return target; +} + +::size_t CabinPreConditionReponse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.CabinPreConditionReponse) + ::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 messageHeader = 1; + if (this->_internal_has_messageheader()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.messageheader_); + } + + // .messages.SetAcStatusReply setAcStatusReply = 2; + if (this->_internal_has_setacstatusreply()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.setacstatusreply_); + } + + // .messages.SetTemperatureReply setTemperatureReply = 3; + if (this->_internal_has_settemperaturereply()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.settemperaturereply_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CabinPreConditionReponse::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + CabinPreConditionReponse::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CabinPreConditionReponse::GetClassData() const { return &_class_data_; } + + +void CabinPreConditionReponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast<CabinPreConditionReponse*>(&to_msg); + auto& from = static_cast<const CabinPreConditionReponse&>(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.CabinPreConditionReponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_messageheader()) { + _this->_internal_mutable_messageheader()->::messages::VehicleMessageHeading::MergeFrom( + from._internal_messageheader()); + } + if (from._internal_has_setacstatusreply()) { + _this->_internal_mutable_setacstatusreply()->::messages::SetAcStatusReply::MergeFrom( + from._internal_setacstatusreply()); + } + if (from._internal_has_settemperaturereply()) { + _this->_internal_mutable_settemperaturereply()->::messages::SetTemperatureReply::MergeFrom( + from._internal_settemperaturereply()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void CabinPreConditionReponse::CopyFrom(const CabinPreConditionReponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.CabinPreConditionReponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CabinPreConditionReponse::IsInitialized() const { + return true; +} + +void CabinPreConditionReponse::InternalSwap(CabinPreConditionReponse* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(CabinPreConditionReponse, _impl_.settemperaturereply_) + + sizeof(CabinPreConditionReponse::_impl_.settemperaturereply_) + - PROTOBUF_FIELD_OFFSET(CabinPreConditionReponse, _impl_.messageheader_)>( + reinterpret_cast<char*>(&_impl_.messageheader_), + reinterpret_cast<char*>(&other->_impl_.messageheader_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata CabinPreConditionReponse::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 SetAcStatusRequest::_Internal { + public: +}; + +SetAcStatusRequest::SetAcStatusRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.SetAcStatusRequest) +} +SetAcStatusRequest::SetAcStatusRequest(const SetAcStatusRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:messages.SetAcStatusRequest) +} + +inline void SetAcStatusRequest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.desiredstatus_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +SetAcStatusRequest::~SetAcStatusRequest() { + // @@protoc_insertion_point(destructor:messages.SetAcStatusRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SetAcStatusRequest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SetAcStatusRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SetAcStatusRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.SetAcStatusRequest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.desiredstatus_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SetAcStatusRequest::_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.AcStatusEnum desiredStatus = 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_desiredstatus(static_cast<::messages::AcStatusEnum>(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* SetAcStatusRequest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.SetAcStatusRequest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.AcStatusEnum desiredStatus = 1; + if (this->_internal_desiredstatus() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_desiredstatus(), 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.SetAcStatusRequest) + return target; +} + +::size_t SetAcStatusRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.SetAcStatusRequest) + ::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.AcStatusEnum desiredStatus = 1; + if (this->_internal_desiredstatus() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_desiredstatus()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SetAcStatusRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SetAcStatusRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetAcStatusRequest::GetClassData() const { return &_class_data_; } + + +void SetAcStatusRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast<SetAcStatusRequest*>(&to_msg); + auto& from = static_cast<const SetAcStatusRequest&>(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.SetAcStatusRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_desiredstatus() != 0) { + _this->_internal_set_desiredstatus(from._internal_desiredstatus()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SetAcStatusRequest::CopyFrom(const SetAcStatusRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.SetAcStatusRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SetAcStatusRequest::IsInitialized() const { + return true; +} + +void SetAcStatusRequest::InternalSwap(SetAcStatusRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.desiredstatus_, other->_impl_.desiredstatus_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SetAcStatusRequest::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 SetAcStatusReply::_Internal { + public: +}; + +SetAcStatusReply::SetAcStatusReply(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.SetAcStatusReply) +} +SetAcStatusReply::SetAcStatusReply(const SetAcStatusReply& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:messages.SetAcStatusReply) +} + +inline void SetAcStatusReply::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.status_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +SetAcStatusReply::~SetAcStatusReply() { + // @@protoc_insertion_point(destructor:messages.SetAcStatusReply) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SetAcStatusReply::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SetAcStatusReply::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SetAcStatusReply::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.SetAcStatusReply) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.status_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SetAcStatusReply::_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.AcStatusEnum 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::AcStatusEnum>(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* SetAcStatusReply::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.SetAcStatusReply) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.AcStatusEnum status = 1; + if (this->_internal_status() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_status(), 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.SetAcStatusReply) + return target; +} + +::size_t SetAcStatusReply::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.SetAcStatusReply) + ::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.AcStatusEnum 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 SetAcStatusReply::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SetAcStatusReply::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetAcStatusReply::GetClassData() const { return &_class_data_; } + + +void SetAcStatusReply::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast<SetAcStatusReply*>(&to_msg); + auto& from = static_cast<const SetAcStatusReply&>(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.SetAcStatusReply) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_status() != 0) { + _this->_internal_set_status(from._internal_status()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SetAcStatusReply::CopyFrom(const SetAcStatusReply& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.SetAcStatusReply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SetAcStatusReply::IsInitialized() const { + return true; +} + +void SetAcStatusReply::InternalSwap(SetAcStatusReply* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.status_, other->_impl_.status_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SetAcStatusReply::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 SetTemperatureRequest::_Internal { + public: +}; + +SetTemperatureRequest::SetTemperatureRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.SetTemperatureRequest) +} +SetTemperatureRequest::SetTemperatureRequest(const SetTemperatureRequest& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:messages.SetTemperatureRequest) +} + +inline void SetTemperatureRequest::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.temperature_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +SetTemperatureRequest::~SetTemperatureRequest() { + // @@protoc_insertion_point(destructor:messages.SetTemperatureRequest) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SetTemperatureRequest::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SetTemperatureRequest::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SetTemperatureRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.SetTemperatureRequest) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.temperature_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SetTemperatureRequest::_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 temperature = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 13)) { + _impl_.temperature_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr); + ptr += sizeof(float); + } 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* SetTemperatureRequest::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.SetTemperatureRequest) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // float temperature = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size."); + float tmp_temperature = this->_internal_temperature(); + ::uint32_t raw_temperature; + memcpy(&raw_temperature, &tmp_temperature, sizeof(tmp_temperature)); + if (raw_temperature != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 1, this->_internal_temperature(), 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.SetTemperatureRequest) + return target; +} + +::size_t SetTemperatureRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.SetTemperatureRequest) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // float temperature = 1; + static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size."); + float tmp_temperature = this->_internal_temperature(); + ::uint32_t raw_temperature; + memcpy(&raw_temperature, &tmp_temperature, sizeof(tmp_temperature)); + if (raw_temperature != 0) { + total_size += 5; + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SetTemperatureRequest::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SetTemperatureRequest::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetTemperatureRequest::GetClassData() const { return &_class_data_; } + + +void SetTemperatureRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast<SetTemperatureRequest*>(&to_msg); + auto& from = static_cast<const SetTemperatureRequest&>(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.SetTemperatureRequest) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + static_assert(sizeof(::uint32_t) == sizeof(float), "Code assumes ::uint32_t and float are the same size."); + float tmp_temperature = from._internal_temperature(); + ::uint32_t raw_temperature; + memcpy(&raw_temperature, &tmp_temperature, sizeof(tmp_temperature)); + if (raw_temperature != 0) { + _this->_internal_set_temperature(from._internal_temperature()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SetTemperatureRequest::CopyFrom(const SetTemperatureRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.SetTemperatureRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SetTemperatureRequest::IsInitialized() const { + return true; +} + +void SetTemperatureRequest::InternalSwap(SetTemperatureRequest* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + + swap(_impl_.temperature_, other->_impl_.temperature_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SetTemperatureRequest::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 SetTemperatureReply::_Internal { + public: +}; + +SetTemperatureReply::SetTemperatureReply(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:messages.SetTemperatureReply) +} +SetTemperatureReply::SetTemperatureReply(const SetTemperatureReply& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), _impl_(from._impl_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>( + from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:messages.SetTemperatureReply) +} + +inline void SetTemperatureReply::SharedCtor(::_pb::Arena* arena) { + (void)arena; + new (&_impl_) Impl_{ + decltype(_impl_.tempstatus_) { 0 } + + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +SetTemperatureReply::~SetTemperatureReply() { + // @@protoc_insertion_point(destructor:messages.SetTemperatureReply) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SetTemperatureReply::SharedDtor() { + ABSL_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SetTemperatureReply::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void SetTemperatureReply::Clear() { +// @@protoc_insertion_point(message_clear_start:messages.SetTemperatureReply) + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.tempstatus_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SetTemperatureReply::_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.SetTempStatusEnum tempStatus = 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_tempstatus(static_cast<::messages::SetTempStatusEnum>(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* SetTemperatureReply::_InternalSerialize( + ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:messages.SetTemperatureReply) + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .messages.SetTempStatusEnum tempStatus = 1; + if (this->_internal_tempstatus() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 1, this->_internal_tempstatus(), 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.SetTemperatureReply) + return target; +} + +::size_t SetTemperatureReply::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:messages.SetTemperatureReply) + ::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.SetTempStatusEnum tempStatus = 1; + if (this->_internal_tempstatus() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this->_internal_tempstatus()); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SetTemperatureReply::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + SetTemperatureReply::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetTemperatureReply::GetClassData() const { return &_class_data_; } + + +void SetTemperatureReply::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast<SetTemperatureReply*>(&to_msg); + auto& from = static_cast<const SetTemperatureReply&>(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:messages.SetTemperatureReply) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_tempstatus() != 0) { + _this->_internal_set_tempstatus(from._internal_tempstatus()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void SetTemperatureReply::CopyFrom(const SetTemperatureReply& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:messages.SetTemperatureReply) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SetTemperatureReply::IsInitialized() const { + return true; +} + +void SetTemperatureReply::InternalSwap(SetTemperatureReply* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.tempstatus_, other->_impl_.tempstatus_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SetTemperatureReply::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_getter, &descriptor_table_messages_2fVehicleRemoteHvac_2eproto_once, + file_level_metadata_messages_2fVehicleRemoteHvac_2eproto[5]); +} +// @@protoc_insertion_point(namespace_scope) +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::messages::CabinPreconditionRequest* +Arena::CreateMaybeMessage< ::messages::CabinPreconditionRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::CabinPreconditionRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::CabinPreConditionReponse* +Arena::CreateMaybeMessage< ::messages::CabinPreConditionReponse >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::CabinPreConditionReponse >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::SetAcStatusRequest* +Arena::CreateMaybeMessage< ::messages::SetAcStatusRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::SetAcStatusRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::SetAcStatusReply* +Arena::CreateMaybeMessage< ::messages::SetAcStatusReply >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::SetAcStatusReply >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::SetTemperatureRequest* +Arena::CreateMaybeMessage< ::messages::SetTemperatureRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::SetTemperatureRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::messages::SetTemperatureReply* +Arena::CreateMaybeMessage< ::messages::SetTemperatureReply >(Arena* arena) { + return Arena::CreateMessageInternal< ::messages::SetTemperatureReply >(arena); +} +PROTOBUF_NAMESPACE_CLOSE +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.h b/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.h new file mode 100644 index 0000000..af50b78 --- /dev/null +++ b/build/generated/source/proto/main/cpp/messages/VehicleRemoteHvac.pb.h @@ -0,0 +1,1786 @@ +// 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 <limits> +#include <string> +#include <type_traits> + +#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 "vss/vspec.pb.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_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 CabinPreConditionReponse; +struct CabinPreConditionReponseDefaultTypeInternal; +extern CabinPreConditionReponseDefaultTypeInternal _CabinPreConditionReponse_default_instance_; +class CabinPreconditionRequest; +struct CabinPreconditionRequestDefaultTypeInternal; +extern CabinPreconditionRequestDefaultTypeInternal _CabinPreconditionRequest_default_instance_; +class SetAcStatusReply; +struct SetAcStatusReplyDefaultTypeInternal; +extern SetAcStatusReplyDefaultTypeInternal _SetAcStatusReply_default_instance_; +class SetAcStatusRequest; +struct SetAcStatusRequestDefaultTypeInternal; +extern SetAcStatusRequestDefaultTypeInternal _SetAcStatusRequest_default_instance_; +class SetTemperatureReply; +struct SetTemperatureReplyDefaultTypeInternal; +extern SetTemperatureReplyDefaultTypeInternal _SetTemperatureReply_default_instance_; +class SetTemperatureRequest; +struct SetTemperatureRequestDefaultTypeInternal; +extern SetTemperatureRequestDefaultTypeInternal _SetTemperatureRequest_default_instance_; +} // namespace messages +PROTOBUF_NAMESPACE_OPEN +template <> +::messages::CabinPreConditionReponse* Arena::CreateMaybeMessage<::messages::CabinPreConditionReponse>(Arena*); +template <> +::messages::CabinPreconditionRequest* Arena::CreateMaybeMessage<::messages::CabinPreconditionRequest>(Arena*); +template <> +::messages::SetAcStatusReply* Arena::CreateMaybeMessage<::messages::SetAcStatusReply>(Arena*); +template <> +::messages::SetAcStatusRequest* Arena::CreateMaybeMessage<::messages::SetAcStatusRequest>(Arena*); +template <> +::messages::SetTemperatureReply* Arena::CreateMaybeMessage<::messages::SetTemperatureReply>(Arena*); +template <> +::messages::SetTemperatureRequest* Arena::CreateMaybeMessage<::messages::SetTemperatureRequest>(Arena*); +PROTOBUF_NAMESPACE_CLOSE + +namespace messages { +enum AcStatusEnum : int { + ON = 0, + OFF = 1, + UKNONWN_ERROR = 2, + AcStatusEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + AcStatusEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool AcStatusEnum_IsValid(int value); +constexpr AcStatusEnum AcStatusEnum_MIN = static_cast<AcStatusEnum>(0); +constexpr AcStatusEnum AcStatusEnum_MAX = static_cast<AcStatusEnum>(2); +constexpr int AcStatusEnum_ARRAYSIZE = 2 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +AcStatusEnum_descriptor(); +template <typename T> +const std::string& AcStatusEnum_Name(T value) { + static_assert(std::is_same<T, AcStatusEnum>::value || + std::is_integral<T>::value, + "Incorrect type passed to AcStatusEnum_Name()."); + return AcStatusEnum_Name(static_cast<AcStatusEnum>(value)); +} +template <> +inline const std::string& AcStatusEnum_Name(AcStatusEnum value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<AcStatusEnum_descriptor, + 0, 2>( + static_cast<int>(value)); +} +inline bool AcStatusEnum_Parse(absl::string_view name, AcStatusEnum* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AcStatusEnum>( + AcStatusEnum_descriptor(), name, value); +} +enum SetTempStatusEnum : int { + TEMP_SUCCESS = 0, + TEMP_ERROR = 1, + SetTempStatusEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::min(), + SetTempStatusEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = + std::numeric_limits<::int32_t>::max(), +}; + +bool SetTempStatusEnum_IsValid(int value); +constexpr SetTempStatusEnum SetTempStatusEnum_MIN = static_cast<SetTempStatusEnum>(0); +constexpr SetTempStatusEnum SetTempStatusEnum_MAX = static_cast<SetTempStatusEnum>(1); +constexpr int SetTempStatusEnum_ARRAYSIZE = 1 + 1; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* +SetTempStatusEnum_descriptor(); +template <typename T> +const std::string& SetTempStatusEnum_Name(T value) { + static_assert(std::is_same<T, SetTempStatusEnum>::value || + std::is_integral<T>::value, + "Incorrect type passed to SetTempStatusEnum_Name()."); + return SetTempStatusEnum_Name(static_cast<SetTempStatusEnum>(value)); +} +template <> +inline const std::string& SetTempStatusEnum_Name(SetTempStatusEnum value) { + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<SetTempStatusEnum_descriptor, + 0, 1>( + static_cast<int>(value)); +} +inline bool SetTempStatusEnum_Parse(absl::string_view name, SetTempStatusEnum* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SetTempStatusEnum>( + SetTempStatusEnum_descriptor(), name, value); +} + +// =================================================================== + + +// ------------------------------------------------------------------- + +class CabinPreconditionRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.CabinPreconditionRequest) */ { + public: + inline CabinPreconditionRequest() : CabinPreconditionRequest(nullptr) {} + ~CabinPreconditionRequest() override; + explicit PROTOBUF_CONSTEXPR CabinPreconditionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CabinPreconditionRequest(const CabinPreconditionRequest& from); + CabinPreconditionRequest(CabinPreconditionRequest&& from) noexcept + : CabinPreconditionRequest() { + *this = ::std::move(from); + } + + inline CabinPreconditionRequest& operator=(const CabinPreconditionRequest& from) { + CopyFrom(from); + return *this; + } + inline CabinPreconditionRequest& operator=(CabinPreconditionRequest&& 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 CabinPreconditionRequest& default_instance() { + return *internal_default_instance(); + } + static inline const CabinPreconditionRequest* internal_default_instance() { + return reinterpret_cast<const CabinPreconditionRequest*>( + &_CabinPreconditionRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(CabinPreconditionRequest& a, CabinPreconditionRequest& b) { + a.Swap(&b); + } + inline void Swap(CabinPreconditionRequest* 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(CabinPreconditionRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CabinPreconditionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<CabinPreconditionRequest>(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CabinPreconditionRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const CabinPreconditionRequest& from) { + CabinPreconditionRequest::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(CabinPreconditionRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.CabinPreconditionRequest"; + } + protected: + explicit CabinPreconditionRequest(::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 { + kMessageHeaderFieldNumber = 1, + kSetAcStatusFieldNumber = 2, + kSetTempFieldNumber = 3, + }; + // .messages.VehicleMessageHeading messageHeader = 1; + bool has_messageheader() const; + private: + bool _internal_has_messageheader() const; + + public: + void clear_messageheader() ; + const ::messages::VehicleMessageHeading& messageheader() const; + PROTOBUF_NODISCARD ::messages::VehicleMessageHeading* release_messageheader(); + ::messages::VehicleMessageHeading* mutable_messageheader(); + void set_allocated_messageheader(::messages::VehicleMessageHeading* messageheader); + private: + const ::messages::VehicleMessageHeading& _internal_messageheader() const; + ::messages::VehicleMessageHeading* _internal_mutable_messageheader(); + public: + void unsafe_arena_set_allocated_messageheader( + ::messages::VehicleMessageHeading* messageheader); + ::messages::VehicleMessageHeading* unsafe_arena_release_messageheader(); + // .messages.SetAcStatusRequest setAcStatus = 2; + bool has_setacstatus() const; + private: + bool _internal_has_setacstatus() const; + + public: + void clear_setacstatus() ; + const ::messages::SetAcStatusRequest& setacstatus() const; + PROTOBUF_NODISCARD ::messages::SetAcStatusRequest* release_setacstatus(); + ::messages::SetAcStatusRequest* mutable_setacstatus(); + void set_allocated_setacstatus(::messages::SetAcStatusRequest* setacstatus); + private: + const ::messages::SetAcStatusRequest& _internal_setacstatus() const; + ::messages::SetAcStatusRequest* _internal_mutable_setacstatus(); + public: + void unsafe_arena_set_allocated_setacstatus( + ::messages::SetAcStatusRequest* setacstatus); + ::messages::SetAcStatusRequest* unsafe_arena_release_setacstatus(); + // .messages.SetTemperatureRequest setTemp = 3; + bool has_settemp() const; + private: + bool _internal_has_settemp() const; + + public: + void clear_settemp() ; + const ::messages::SetTemperatureRequest& settemp() const; + PROTOBUF_NODISCARD ::messages::SetTemperatureRequest* release_settemp(); + ::messages::SetTemperatureRequest* mutable_settemp(); + void set_allocated_settemp(::messages::SetTemperatureRequest* settemp); + private: + const ::messages::SetTemperatureRequest& _internal_settemp() const; + ::messages::SetTemperatureRequest* _internal_mutable_settemp(); + public: + void unsafe_arena_set_allocated_settemp( + ::messages::SetTemperatureRequest* settemp); + ::messages::SetTemperatureRequest* unsafe_arena_release_settemp(); + // @@protoc_insertion_point(class_scope:messages.CabinPreconditionRequest) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::messages::VehicleMessageHeading* messageheader_; + ::messages::SetAcStatusRequest* setacstatus_; + ::messages::SetTemperatureRequest* settemp_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class CabinPreConditionReponse final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.CabinPreConditionReponse) */ { + public: + inline CabinPreConditionReponse() : CabinPreConditionReponse(nullptr) {} + ~CabinPreConditionReponse() override; + explicit PROTOBUF_CONSTEXPR CabinPreConditionReponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + CabinPreConditionReponse(const CabinPreConditionReponse& from); + CabinPreConditionReponse(CabinPreConditionReponse&& from) noexcept + : CabinPreConditionReponse() { + *this = ::std::move(from); + } + + inline CabinPreConditionReponse& operator=(const CabinPreConditionReponse& from) { + CopyFrom(from); + return *this; + } + inline CabinPreConditionReponse& operator=(CabinPreConditionReponse&& 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 CabinPreConditionReponse& default_instance() { + return *internal_default_instance(); + } + static inline const CabinPreConditionReponse* internal_default_instance() { + return reinterpret_cast<const CabinPreConditionReponse*>( + &_CabinPreConditionReponse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(CabinPreConditionReponse& a, CabinPreConditionReponse& b) { + a.Swap(&b); + } + inline void Swap(CabinPreConditionReponse* 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(CabinPreConditionReponse* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CabinPreConditionReponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<CabinPreConditionReponse>(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const CabinPreConditionReponse& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const CabinPreConditionReponse& from) { + CabinPreConditionReponse::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(CabinPreConditionReponse* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.CabinPreConditionReponse"; + } + protected: + explicit CabinPreConditionReponse(::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 { + kMessageHeaderFieldNumber = 1, + kSetAcStatusReplyFieldNumber = 2, + kSetTemperatureReplyFieldNumber = 3, + }; + // .messages.VehicleMessageHeading messageHeader = 1; + bool has_messageheader() const; + private: + bool _internal_has_messageheader() const; + + public: + void clear_messageheader() ; + const ::messages::VehicleMessageHeading& messageheader() const; + PROTOBUF_NODISCARD ::messages::VehicleMessageHeading* release_messageheader(); + ::messages::VehicleMessageHeading* mutable_messageheader(); + void set_allocated_messageheader(::messages::VehicleMessageHeading* messageheader); + private: + const ::messages::VehicleMessageHeading& _internal_messageheader() const; + ::messages::VehicleMessageHeading* _internal_mutable_messageheader(); + public: + void unsafe_arena_set_allocated_messageheader( + ::messages::VehicleMessageHeading* messageheader); + ::messages::VehicleMessageHeading* unsafe_arena_release_messageheader(); + // .messages.SetAcStatusReply setAcStatusReply = 2; + bool has_setacstatusreply() const; + private: + bool _internal_has_setacstatusreply() const; + + public: + void clear_setacstatusreply() ; + const ::messages::SetAcStatusReply& setacstatusreply() const; + PROTOBUF_NODISCARD ::messages::SetAcStatusReply* release_setacstatusreply(); + ::messages::SetAcStatusReply* mutable_setacstatusreply(); + void set_allocated_setacstatusreply(::messages::SetAcStatusReply* setacstatusreply); + private: + const ::messages::SetAcStatusReply& _internal_setacstatusreply() const; + ::messages::SetAcStatusReply* _internal_mutable_setacstatusreply(); + public: + void unsafe_arena_set_allocated_setacstatusreply( + ::messages::SetAcStatusReply* setacstatusreply); + ::messages::SetAcStatusReply* unsafe_arena_release_setacstatusreply(); + // .messages.SetTemperatureReply setTemperatureReply = 3; + bool has_settemperaturereply() const; + private: + bool _internal_has_settemperaturereply() const; + + public: + void clear_settemperaturereply() ; + const ::messages::SetTemperatureReply& settemperaturereply() const; + PROTOBUF_NODISCARD ::messages::SetTemperatureReply* release_settemperaturereply(); + ::messages::SetTemperatureReply* mutable_settemperaturereply(); + void set_allocated_settemperaturereply(::messages::SetTemperatureReply* settemperaturereply); + private: + const ::messages::SetTemperatureReply& _internal_settemperaturereply() const; + ::messages::SetTemperatureReply* _internal_mutable_settemperaturereply(); + public: + void unsafe_arena_set_allocated_settemperaturereply( + ::messages::SetTemperatureReply* settemperaturereply); + ::messages::SetTemperatureReply* unsafe_arena_release_settemperaturereply(); + // @@protoc_insertion_point(class_scope:messages.CabinPreConditionReponse) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::messages::VehicleMessageHeading* messageheader_; + ::messages::SetAcStatusReply* setacstatusreply_; + ::messages::SetTemperatureReply* settemperaturereply_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class SetAcStatusRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.SetAcStatusRequest) */ { + public: + inline SetAcStatusRequest() : SetAcStatusRequest(nullptr) {} + ~SetAcStatusRequest() override; + explicit PROTOBUF_CONSTEXPR SetAcStatusRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SetAcStatusRequest(const SetAcStatusRequest& from); + SetAcStatusRequest(SetAcStatusRequest&& from) noexcept + : SetAcStatusRequest() { + *this = ::std::move(from); + } + + inline SetAcStatusRequest& operator=(const SetAcStatusRequest& from) { + CopyFrom(from); + return *this; + } + inline SetAcStatusRequest& operator=(SetAcStatusRequest&& 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 SetAcStatusRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SetAcStatusRequest* internal_default_instance() { + return reinterpret_cast<const SetAcStatusRequest*>( + &_SetAcStatusRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(SetAcStatusRequest& a, SetAcStatusRequest& b) { + a.Swap(&b); + } + inline void Swap(SetAcStatusRequest* 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(SetAcStatusRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetAcStatusRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<SetAcStatusRequest>(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SetAcStatusRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SetAcStatusRequest& from) { + SetAcStatusRequest::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(SetAcStatusRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.SetAcStatusRequest"; + } + protected: + explicit SetAcStatusRequest(::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 { + kDesiredStatusFieldNumber = 1, + }; + // .messages.AcStatusEnum desiredStatus = 1; + void clear_desiredstatus() ; + ::messages::AcStatusEnum desiredstatus() const; + void set_desiredstatus(::messages::AcStatusEnum value); + + private: + ::messages::AcStatusEnum _internal_desiredstatus() const; + void _internal_set_desiredstatus(::messages::AcStatusEnum value); + + public: + // @@protoc_insertion_point(class_scope:messages.SetAcStatusRequest) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + int desiredstatus_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class SetAcStatusReply final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.SetAcStatusReply) */ { + public: + inline SetAcStatusReply() : SetAcStatusReply(nullptr) {} + ~SetAcStatusReply() override; + explicit PROTOBUF_CONSTEXPR SetAcStatusReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SetAcStatusReply(const SetAcStatusReply& from); + SetAcStatusReply(SetAcStatusReply&& from) noexcept + : SetAcStatusReply() { + *this = ::std::move(from); + } + + inline SetAcStatusReply& operator=(const SetAcStatusReply& from) { + CopyFrom(from); + return *this; + } + inline SetAcStatusReply& operator=(SetAcStatusReply&& 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 SetAcStatusReply& default_instance() { + return *internal_default_instance(); + } + static inline const SetAcStatusReply* internal_default_instance() { + return reinterpret_cast<const SetAcStatusReply*>( + &_SetAcStatusReply_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(SetAcStatusReply& a, SetAcStatusReply& b) { + a.Swap(&b); + } + inline void Swap(SetAcStatusReply* 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(SetAcStatusReply* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetAcStatusReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<SetAcStatusReply>(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SetAcStatusReply& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SetAcStatusReply& from) { + SetAcStatusReply::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(SetAcStatusReply* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.SetAcStatusReply"; + } + protected: + explicit SetAcStatusReply(::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 { + kStatusFieldNumber = 1, + }; + // .messages.AcStatusEnum status = 1; + void clear_status() ; + ::messages::AcStatusEnum status() const; + void set_status(::messages::AcStatusEnum value); + + private: + ::messages::AcStatusEnum _internal_status() const; + void _internal_set_status(::messages::AcStatusEnum value); + + public: + // @@protoc_insertion_point(class_scope:messages.SetAcStatusReply) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + int status_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class SetTemperatureRequest final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.SetTemperatureRequest) */ { + public: + inline SetTemperatureRequest() : SetTemperatureRequest(nullptr) {} + ~SetTemperatureRequest() override; + explicit PROTOBUF_CONSTEXPR SetTemperatureRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SetTemperatureRequest(const SetTemperatureRequest& from); + SetTemperatureRequest(SetTemperatureRequest&& from) noexcept + : SetTemperatureRequest() { + *this = ::std::move(from); + } + + inline SetTemperatureRequest& operator=(const SetTemperatureRequest& from) { + CopyFrom(from); + return *this; + } + inline SetTemperatureRequest& operator=(SetTemperatureRequest&& 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 SetTemperatureRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SetTemperatureRequest* internal_default_instance() { + return reinterpret_cast<const SetTemperatureRequest*>( + &_SetTemperatureRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(SetTemperatureRequest& a, SetTemperatureRequest& b) { + a.Swap(&b); + } + inline void Swap(SetTemperatureRequest* 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(SetTemperatureRequest* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetTemperatureRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<SetTemperatureRequest>(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SetTemperatureRequest& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SetTemperatureRequest& from) { + SetTemperatureRequest::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(SetTemperatureRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.SetTemperatureRequest"; + } + protected: + explicit SetTemperatureRequest(::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, + }; + // float temperature = 1; + void clear_temperature() ; + float temperature() const; + void set_temperature(float value); + + private: + float _internal_temperature() const; + void _internal_set_temperature(float value); + + public: + // @@protoc_insertion_point(class_scope:messages.SetTemperatureRequest) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + float temperature_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_messages_2fVehicleRemoteHvac_2eproto; +};// ------------------------------------------------------------------- + +class SetTemperatureReply final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:messages.SetTemperatureReply) */ { + public: + inline SetTemperatureReply() : SetTemperatureReply(nullptr) {} + ~SetTemperatureReply() override; + explicit PROTOBUF_CONSTEXPR SetTemperatureReply(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SetTemperatureReply(const SetTemperatureReply& from); + SetTemperatureReply(SetTemperatureReply&& from) noexcept + : SetTemperatureReply() { + *this = ::std::move(from); + } + + inline SetTemperatureReply& operator=(const SetTemperatureReply& from) { + CopyFrom(from); + return *this; + } + inline SetTemperatureReply& operator=(SetTemperatureReply&& 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 SetTemperatureReply& default_instance() { + return *internal_default_instance(); + } + static inline const SetTemperatureReply* internal_default_instance() { + return reinterpret_cast<const SetTemperatureReply*>( + &_SetTemperatureReply_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(SetTemperatureReply& a, SetTemperatureReply& b) { + a.Swap(&b); + } + inline void Swap(SetTemperatureReply* 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(SetTemperatureReply* other) { + if (other == this) return; + ABSL_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetTemperatureReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage<SetTemperatureReply>(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const SetTemperatureReply& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const SetTemperatureReply& from) { + SetTemperatureReply::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(SetTemperatureReply* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::absl::string_view FullMessageName() { + return "messages.SetTemperatureReply"; + } + protected: + explicit SetTemperatureReply(::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 { + kTempStatusFieldNumber = 1, + }; + // .messages.SetTempStatusEnum tempStatus = 1; + void clear_tempstatus() ; + ::messages::SetTempStatusEnum tempstatus() const; + void set_tempstatus(::messages::SetTempStatusEnum value); + + private: + ::messages::SetTempStatusEnum _internal_tempstatus() const; + void _internal_set_tempstatus(::messages::SetTempStatusEnum value); + + public: + // @@protoc_insertion_point(class_scope:messages.SetTemperatureReply) + private: + class _Internal; + + template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + int tempstatus_; + 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__ +// ------------------------------------------------------------------- + +// CabinPreconditionRequest + +// .messages.VehicleMessageHeading messageHeader = 1; +inline bool CabinPreconditionRequest::_internal_has_messageheader() const { + return this != internal_default_instance() && _impl_.messageheader_ != nullptr; +} +inline bool CabinPreconditionRequest::has_messageheader() const { + return _internal_has_messageheader(); +} +inline const ::messages::VehicleMessageHeading& CabinPreconditionRequest::_internal_messageheader() const { + const ::messages::VehicleMessageHeading* p = _impl_.messageheader_; + return p != nullptr ? *p : reinterpret_cast<const ::messages::VehicleMessageHeading&>( + ::messages::_VehicleMessageHeading_default_instance_); +} +inline const ::messages::VehicleMessageHeading& CabinPreconditionRequest::messageheader() const { + // @@protoc_insertion_point(field_get:messages.CabinPreconditionRequest.messageHeader) + return _internal_messageheader(); +} +inline void CabinPreconditionRequest::unsafe_arena_set_allocated_messageheader( + ::messages::VehicleMessageHeading* messageheader) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messageheader_); + } + _impl_.messageheader_ = messageheader; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreconditionRequest.messageHeader) +} +inline ::messages::VehicleMessageHeading* CabinPreconditionRequest::release_messageheader() { + + ::messages::VehicleMessageHeading* temp = _impl_.messageheader_; + _impl_.messageheader_ = 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* CabinPreconditionRequest::unsafe_arena_release_messageheader() { + // @@protoc_insertion_point(field_release:messages.CabinPreconditionRequest.messageHeader) + + ::messages::VehicleMessageHeading* temp = _impl_.messageheader_; + _impl_.messageheader_ = nullptr; + return temp; +} +inline ::messages::VehicleMessageHeading* CabinPreconditionRequest::_internal_mutable_messageheader() { + + if (_impl_.messageheader_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::VehicleMessageHeading>(GetArenaForAllocation()); + _impl_.messageheader_ = p; + } + return _impl_.messageheader_; +} +inline ::messages::VehicleMessageHeading* CabinPreconditionRequest::mutable_messageheader() { + ::messages::VehicleMessageHeading* _msg = _internal_mutable_messageheader(); + // @@protoc_insertion_point(field_mutable:messages.CabinPreconditionRequest.messageHeader) + return _msg; +} +inline void CabinPreconditionRequest::set_allocated_messageheader(::messages::VehicleMessageHeading* messageheader) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messageheader_); + } + if (messageheader) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(messageheader)); + if (message_arena != submessage_arena) { + messageheader = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, messageheader, submessage_arena); + } + + } else { + + } + _impl_.messageheader_ = messageheader; + // @@protoc_insertion_point(field_set_allocated:messages.CabinPreconditionRequest.messageHeader) +} + +// .messages.SetAcStatusRequest setAcStatus = 2; +inline bool CabinPreconditionRequest::_internal_has_setacstatus() const { + return this != internal_default_instance() && _impl_.setacstatus_ != nullptr; +} +inline bool CabinPreconditionRequest::has_setacstatus() const { + return _internal_has_setacstatus(); +} +inline void CabinPreconditionRequest::clear_setacstatus() { + if (GetArenaForAllocation() == nullptr && _impl_.setacstatus_ != nullptr) { + delete _impl_.setacstatus_; + } + _impl_.setacstatus_ = nullptr; +} +inline const ::messages::SetAcStatusRequest& CabinPreconditionRequest::_internal_setacstatus() const { + const ::messages::SetAcStatusRequest* p = _impl_.setacstatus_; + return p != nullptr ? *p : reinterpret_cast<const ::messages::SetAcStatusRequest&>( + ::messages::_SetAcStatusRequest_default_instance_); +} +inline const ::messages::SetAcStatusRequest& CabinPreconditionRequest::setacstatus() const { + // @@protoc_insertion_point(field_get:messages.CabinPreconditionRequest.setAcStatus) + return _internal_setacstatus(); +} +inline void CabinPreconditionRequest::unsafe_arena_set_allocated_setacstatus( + ::messages::SetAcStatusRequest* setacstatus) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.setacstatus_); + } + _impl_.setacstatus_ = setacstatus; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreconditionRequest.setAcStatus) +} +inline ::messages::SetAcStatusRequest* CabinPreconditionRequest::release_setacstatus() { + + ::messages::SetAcStatusRequest* temp = _impl_.setacstatus_; + _impl_.setacstatus_ = 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::SetAcStatusRequest* CabinPreconditionRequest::unsafe_arena_release_setacstatus() { + // @@protoc_insertion_point(field_release:messages.CabinPreconditionRequest.setAcStatus) + + ::messages::SetAcStatusRequest* temp = _impl_.setacstatus_; + _impl_.setacstatus_ = nullptr; + return temp; +} +inline ::messages::SetAcStatusRequest* CabinPreconditionRequest::_internal_mutable_setacstatus() { + + if (_impl_.setacstatus_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::SetAcStatusRequest>(GetArenaForAllocation()); + _impl_.setacstatus_ = p; + } + return _impl_.setacstatus_; +} +inline ::messages::SetAcStatusRequest* CabinPreconditionRequest::mutable_setacstatus() { + ::messages::SetAcStatusRequest* _msg = _internal_mutable_setacstatus(); + // @@protoc_insertion_point(field_mutable:messages.CabinPreconditionRequest.setAcStatus) + return _msg; +} +inline void CabinPreconditionRequest::set_allocated_setacstatus(::messages::SetAcStatusRequest* setacstatus) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.setacstatus_; + } + if (setacstatus) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(setacstatus); + if (message_arena != submessage_arena) { + setacstatus = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, setacstatus, submessage_arena); + } + + } else { + + } + _impl_.setacstatus_ = setacstatus; + // @@protoc_insertion_point(field_set_allocated:messages.CabinPreconditionRequest.setAcStatus) +} + +// .messages.SetTemperatureRequest setTemp = 3; +inline bool CabinPreconditionRequest::_internal_has_settemp() const { + return this != internal_default_instance() && _impl_.settemp_ != nullptr; +} +inline bool CabinPreconditionRequest::has_settemp() const { + return _internal_has_settemp(); +} +inline void CabinPreconditionRequest::clear_settemp() { + if (GetArenaForAllocation() == nullptr && _impl_.settemp_ != nullptr) { + delete _impl_.settemp_; + } + _impl_.settemp_ = nullptr; +} +inline const ::messages::SetTemperatureRequest& CabinPreconditionRequest::_internal_settemp() const { + const ::messages::SetTemperatureRequest* p = _impl_.settemp_; + return p != nullptr ? *p : reinterpret_cast<const ::messages::SetTemperatureRequest&>( + ::messages::_SetTemperatureRequest_default_instance_); +} +inline const ::messages::SetTemperatureRequest& CabinPreconditionRequest::settemp() const { + // @@protoc_insertion_point(field_get:messages.CabinPreconditionRequest.setTemp) + return _internal_settemp(); +} +inline void CabinPreconditionRequest::unsafe_arena_set_allocated_settemp( + ::messages::SetTemperatureRequest* settemp) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.settemp_); + } + _impl_.settemp_ = settemp; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreconditionRequest.setTemp) +} +inline ::messages::SetTemperatureRequest* CabinPreconditionRequest::release_settemp() { + + ::messages::SetTemperatureRequest* temp = _impl_.settemp_; + _impl_.settemp_ = 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::SetTemperatureRequest* CabinPreconditionRequest::unsafe_arena_release_settemp() { + // @@protoc_insertion_point(field_release:messages.CabinPreconditionRequest.setTemp) + + ::messages::SetTemperatureRequest* temp = _impl_.settemp_; + _impl_.settemp_ = nullptr; + return temp; +} +inline ::messages::SetTemperatureRequest* CabinPreconditionRequest::_internal_mutable_settemp() { + + if (_impl_.settemp_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::SetTemperatureRequest>(GetArenaForAllocation()); + _impl_.settemp_ = p; + } + return _impl_.settemp_; +} +inline ::messages::SetTemperatureRequest* CabinPreconditionRequest::mutable_settemp() { + ::messages::SetTemperatureRequest* _msg = _internal_mutable_settemp(); + // @@protoc_insertion_point(field_mutable:messages.CabinPreconditionRequest.setTemp) + return _msg; +} +inline void CabinPreconditionRequest::set_allocated_settemp(::messages::SetTemperatureRequest* settemp) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.settemp_; + } + if (settemp) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(settemp); + if (message_arena != submessage_arena) { + settemp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, settemp, submessage_arena); + } + + } else { + + } + _impl_.settemp_ = settemp; + // @@protoc_insertion_point(field_set_allocated:messages.CabinPreconditionRequest.setTemp) +} + +// ------------------------------------------------------------------- + +// CabinPreConditionReponse + +// .messages.VehicleMessageHeading messageHeader = 1; +inline bool CabinPreConditionReponse::_internal_has_messageheader() const { + return this != internal_default_instance() && _impl_.messageheader_ != nullptr; +} +inline bool CabinPreConditionReponse::has_messageheader() const { + return _internal_has_messageheader(); +} +inline const ::messages::VehicleMessageHeading& CabinPreConditionReponse::_internal_messageheader() const { + const ::messages::VehicleMessageHeading* p = _impl_.messageheader_; + return p != nullptr ? *p : reinterpret_cast<const ::messages::VehicleMessageHeading&>( + ::messages::_VehicleMessageHeading_default_instance_); +} +inline const ::messages::VehicleMessageHeading& CabinPreConditionReponse::messageheader() const { + // @@protoc_insertion_point(field_get:messages.CabinPreConditionReponse.messageHeader) + return _internal_messageheader(); +} +inline void CabinPreConditionReponse::unsafe_arena_set_allocated_messageheader( + ::messages::VehicleMessageHeading* messageheader) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messageheader_); + } + _impl_.messageheader_ = messageheader; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreConditionReponse.messageHeader) +} +inline ::messages::VehicleMessageHeading* CabinPreConditionReponse::release_messageheader() { + + ::messages::VehicleMessageHeading* temp = _impl_.messageheader_; + _impl_.messageheader_ = 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* CabinPreConditionReponse::unsafe_arena_release_messageheader() { + // @@protoc_insertion_point(field_release:messages.CabinPreConditionReponse.messageHeader) + + ::messages::VehicleMessageHeading* temp = _impl_.messageheader_; + _impl_.messageheader_ = nullptr; + return temp; +} +inline ::messages::VehicleMessageHeading* CabinPreConditionReponse::_internal_mutable_messageheader() { + + if (_impl_.messageheader_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::VehicleMessageHeading>(GetArenaForAllocation()); + _impl_.messageheader_ = p; + } + return _impl_.messageheader_; +} +inline ::messages::VehicleMessageHeading* CabinPreConditionReponse::mutable_messageheader() { + ::messages::VehicleMessageHeading* _msg = _internal_mutable_messageheader(); + // @@protoc_insertion_point(field_mutable:messages.CabinPreConditionReponse.messageHeader) + return _msg; +} +inline void CabinPreConditionReponse::set_allocated_messageheader(::messages::VehicleMessageHeading* messageheader) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.messageheader_); + } + if (messageheader) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(messageheader)); + if (message_arena != submessage_arena) { + messageheader = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, messageheader, submessage_arena); + } + + } else { + + } + _impl_.messageheader_ = messageheader; + // @@protoc_insertion_point(field_set_allocated:messages.CabinPreConditionReponse.messageHeader) +} + +// .messages.SetAcStatusReply setAcStatusReply = 2; +inline bool CabinPreConditionReponse::_internal_has_setacstatusreply() const { + return this != internal_default_instance() && _impl_.setacstatusreply_ != nullptr; +} +inline bool CabinPreConditionReponse::has_setacstatusreply() const { + return _internal_has_setacstatusreply(); +} +inline void CabinPreConditionReponse::clear_setacstatusreply() { + if (GetArenaForAllocation() == nullptr && _impl_.setacstatusreply_ != nullptr) { + delete _impl_.setacstatusreply_; + } + _impl_.setacstatusreply_ = nullptr; +} +inline const ::messages::SetAcStatusReply& CabinPreConditionReponse::_internal_setacstatusreply() const { + const ::messages::SetAcStatusReply* p = _impl_.setacstatusreply_; + return p != nullptr ? *p : reinterpret_cast<const ::messages::SetAcStatusReply&>( + ::messages::_SetAcStatusReply_default_instance_); +} +inline const ::messages::SetAcStatusReply& CabinPreConditionReponse::setacstatusreply() const { + // @@protoc_insertion_point(field_get:messages.CabinPreConditionReponse.setAcStatusReply) + return _internal_setacstatusreply(); +} +inline void CabinPreConditionReponse::unsafe_arena_set_allocated_setacstatusreply( + ::messages::SetAcStatusReply* setacstatusreply) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.setacstatusreply_); + } + _impl_.setacstatusreply_ = setacstatusreply; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreConditionReponse.setAcStatusReply) +} +inline ::messages::SetAcStatusReply* CabinPreConditionReponse::release_setacstatusreply() { + + ::messages::SetAcStatusReply* temp = _impl_.setacstatusreply_; + _impl_.setacstatusreply_ = 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::SetAcStatusReply* CabinPreConditionReponse::unsafe_arena_release_setacstatusreply() { + // @@protoc_insertion_point(field_release:messages.CabinPreConditionReponse.setAcStatusReply) + + ::messages::SetAcStatusReply* temp = _impl_.setacstatusreply_; + _impl_.setacstatusreply_ = nullptr; + return temp; +} +inline ::messages::SetAcStatusReply* CabinPreConditionReponse::_internal_mutable_setacstatusreply() { + + if (_impl_.setacstatusreply_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::SetAcStatusReply>(GetArenaForAllocation()); + _impl_.setacstatusreply_ = p; + } + return _impl_.setacstatusreply_; +} +inline ::messages::SetAcStatusReply* CabinPreConditionReponse::mutable_setacstatusreply() { + ::messages::SetAcStatusReply* _msg = _internal_mutable_setacstatusreply(); + // @@protoc_insertion_point(field_mutable:messages.CabinPreConditionReponse.setAcStatusReply) + return _msg; +} +inline void CabinPreConditionReponse::set_allocated_setacstatusreply(::messages::SetAcStatusReply* setacstatusreply) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.setacstatusreply_; + } + if (setacstatusreply) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(setacstatusreply); + if (message_arena != submessage_arena) { + setacstatusreply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, setacstatusreply, submessage_arena); + } + + } else { + + } + _impl_.setacstatusreply_ = setacstatusreply; + // @@protoc_insertion_point(field_set_allocated:messages.CabinPreConditionReponse.setAcStatusReply) +} + +// .messages.SetTemperatureReply setTemperatureReply = 3; +inline bool CabinPreConditionReponse::_internal_has_settemperaturereply() const { + return this != internal_default_instance() && _impl_.settemperaturereply_ != nullptr; +} +inline bool CabinPreConditionReponse::has_settemperaturereply() const { + return _internal_has_settemperaturereply(); +} +inline void CabinPreConditionReponse::clear_settemperaturereply() { + if (GetArenaForAllocation() == nullptr && _impl_.settemperaturereply_ != nullptr) { + delete _impl_.settemperaturereply_; + } + _impl_.settemperaturereply_ = nullptr; +} +inline const ::messages::SetTemperatureReply& CabinPreConditionReponse::_internal_settemperaturereply() const { + const ::messages::SetTemperatureReply* p = _impl_.settemperaturereply_; + return p != nullptr ? *p : reinterpret_cast<const ::messages::SetTemperatureReply&>( + ::messages::_SetTemperatureReply_default_instance_); +} +inline const ::messages::SetTemperatureReply& CabinPreConditionReponse::settemperaturereply() const { + // @@protoc_insertion_point(field_get:messages.CabinPreConditionReponse.setTemperatureReply) + return _internal_settemperaturereply(); +} +inline void CabinPreConditionReponse::unsafe_arena_set_allocated_settemperaturereply( + ::messages::SetTemperatureReply* settemperaturereply) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.settemperaturereply_); + } + _impl_.settemperaturereply_ = settemperaturereply; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:messages.CabinPreConditionReponse.setTemperatureReply) +} +inline ::messages::SetTemperatureReply* CabinPreConditionReponse::release_settemperaturereply() { + + ::messages::SetTemperatureReply* temp = _impl_.settemperaturereply_; + _impl_.settemperaturereply_ = 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::SetTemperatureReply* CabinPreConditionReponse::unsafe_arena_release_settemperaturereply() { + // @@protoc_insertion_point(field_release:messages.CabinPreConditionReponse.setTemperatureReply) + + ::messages::SetTemperatureReply* temp = _impl_.settemperaturereply_; + _impl_.settemperaturereply_ = nullptr; + return temp; +} +inline ::messages::SetTemperatureReply* CabinPreConditionReponse::_internal_mutable_settemperaturereply() { + + if (_impl_.settemperaturereply_ == nullptr) { + auto* p = CreateMaybeMessage<::messages::SetTemperatureReply>(GetArenaForAllocation()); + _impl_.settemperaturereply_ = p; + } + return _impl_.settemperaturereply_; +} +inline ::messages::SetTemperatureReply* CabinPreConditionReponse::mutable_settemperaturereply() { + ::messages::SetTemperatureReply* _msg = _internal_mutable_settemperaturereply(); + // @@protoc_insertion_point(field_mutable:messages.CabinPreConditionReponse.setTemperatureReply) + return _msg; +} +inline void CabinPreConditionReponse::set_allocated_settemperaturereply(::messages::SetTemperatureReply* settemperaturereply) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete _impl_.settemperaturereply_; + } + if (settemperaturereply) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(settemperaturereply); + if (message_arena != submessage_arena) { + settemperaturereply = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, settemperaturereply, submessage_arena); + } + + } else { + + } + _impl_.settemperaturereply_ = settemperaturereply; + // @@protoc_insertion_point(field_set_allocated:messages.CabinPreConditionReponse.setTemperatureReply) +} + +// ------------------------------------------------------------------- + +// SetAcStatusRequest + +// .messages.AcStatusEnum desiredStatus = 1; +inline void SetAcStatusRequest::clear_desiredstatus() { + _impl_.desiredstatus_ = 0; +} +inline ::messages::AcStatusEnum SetAcStatusRequest::desiredstatus() const { + // @@protoc_insertion_point(field_get:messages.SetAcStatusRequest.desiredStatus) + return _internal_desiredstatus(); +} +inline void SetAcStatusRequest::set_desiredstatus(::messages::AcStatusEnum value) { + _internal_set_desiredstatus(value); + // @@protoc_insertion_point(field_set:messages.SetAcStatusRequest.desiredStatus) +} +inline ::messages::AcStatusEnum SetAcStatusRequest::_internal_desiredstatus() const { + return static_cast<::messages::AcStatusEnum>(_impl_.desiredstatus_); +} +inline void SetAcStatusRequest::_internal_set_desiredstatus(::messages::AcStatusEnum value) { + ; + _impl_.desiredstatus_ = value; +} + +// ------------------------------------------------------------------- + +// SetAcStatusReply + +// .messages.AcStatusEnum status = 1; +inline void SetAcStatusReply::clear_status() { + _impl_.status_ = 0; +} +inline ::messages::AcStatusEnum SetAcStatusReply::status() const { + // @@protoc_insertion_point(field_get:messages.SetAcStatusReply.status) + return _internal_status(); +} +inline void SetAcStatusReply::set_status(::messages::AcStatusEnum value) { + _internal_set_status(value); + // @@protoc_insertion_point(field_set:messages.SetAcStatusReply.status) +} +inline ::messages::AcStatusEnum SetAcStatusReply::_internal_status() const { + return static_cast<::messages::AcStatusEnum>(_impl_.status_); +} +inline void SetAcStatusReply::_internal_set_status(::messages::AcStatusEnum value) { + ; + _impl_.status_ = value; +} + +// ------------------------------------------------------------------- + +// SetTemperatureRequest + +// float temperature = 1; +inline void SetTemperatureRequest::clear_temperature() { + _impl_.temperature_ = 0; +} +inline float SetTemperatureRequest::temperature() const { + // @@protoc_insertion_point(field_get:messages.SetTemperatureRequest.temperature) + return _internal_temperature(); +} +inline void SetTemperatureRequest::set_temperature(float value) { + _internal_set_temperature(value); + // @@protoc_insertion_point(field_set:messages.SetTemperatureRequest.temperature) +} +inline float SetTemperatureRequest::_internal_temperature() const { + return _impl_.temperature_; +} +inline void SetTemperatureRequest::_internal_set_temperature(float value) { + ; + _impl_.temperature_ = value; +} + +// ------------------------------------------------------------------- + +// SetTemperatureReply + +// .messages.SetTempStatusEnum tempStatus = 1; +inline void SetTemperatureReply::clear_tempstatus() { + _impl_.tempstatus_ = 0; +} +inline ::messages::SetTempStatusEnum SetTemperatureReply::tempstatus() const { + // @@protoc_insertion_point(field_get:messages.SetTemperatureReply.tempStatus) + return _internal_tempstatus(); +} +inline void SetTemperatureReply::set_tempstatus(::messages::SetTempStatusEnum value) { + _internal_set_tempstatus(value); + // @@protoc_insertion_point(field_set:messages.SetTemperatureReply.tempStatus) +} +inline ::messages::SetTempStatusEnum SetTemperatureReply::_internal_tempstatus() const { + return static_cast<::messages::SetTempStatusEnum>(_impl_.tempstatus_); +} +inline void SetTemperatureReply::_internal_set_tempstatus(::messages::SetTempStatusEnum value) { + ; + _impl_.tempstatus_ = 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::AcStatusEnum> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::messages::AcStatusEnum>() { + return ::messages::AcStatusEnum_descriptor(); +} +template <> +struct is_proto_enum<::messages::SetTempStatusEnum> : std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor<::messages::SetTempStatusEnum>() { + return ::messages::SetTempStatusEnum_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // GOOGLE_PROTOBUF_INCLUDED_messages_2fVehicleRemoteHvac_2eproto_2epb_2eh |