From ea8a1ed73784b95fef0e7cb0a0e64a1a6aa9b89e Mon Sep 17 00:00:00 2001 From: Nick Bourdakos Date: Tue, 10 Jan 2023 15:18:12 -0500 Subject: [PATCH] Copy implemenation protos into cpp folder so clients can be refactored --- compiled_proto/connections/.DS_Store | Bin 0 -> 6148 bytes .../proto/offline_wire_formats.pb.cc | 9912 +++++++++++++ .../proto/offline_wire_formats.pb.h | 11883 ++++++++++++++++ 3 files changed, 21795 insertions(+) create mode 100644 compiled_proto/connections/.DS_Store create mode 100644 compiled_proto/connections/cpp/implementation/proto/offline_wire_formats.pb.cc create mode 100644 compiled_proto/connections/cpp/implementation/proto/offline_wire_formats.pb.h diff --git a/compiled_proto/connections/.DS_Store b/compiled_proto/connections/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..ff3215f85682e2e29c9c1a4a8af6c0a7fbd07dcd GIT binary patch literal 6148 zcmeHKJ5Iwu5S<|@EYYN-+$*G|GLbn!N*a_zf+CjP(7WRXoPaZM0`3KGK767TE-9in z(#-SDXV-qkjz>gv^K@8?tVE=N8p^YoS}bl_$whjWK(#&A+x^gwRofB}AOmE844gXy=-DRCWgsmX zAOmFJn*qBY3e>PooC5vofbkIkXut6;c=lNWSj+)z6Q@9UAR48>DAgP>G|J&Gnb#&x zfl)5%Cu5&HS#v^BKOO$!>7s2QEg2vKrwlA&xw8I$3;kpMKP}>l43L4dVnCPOw%g#7 zvbRor$8@<-^+pg5injTWZ*v-_ymRy BCwTw> literal 0 HcmV?d00001 diff --git a/compiled_proto/connections/cpp/implementation/proto/offline_wire_formats.pb.cc b/compiled_proto/connections/cpp/implementation/proto/offline_wire_formats.pb.cc new file mode 100644 index 00000000..ccb71db7 --- /dev/null +++ b/compiled_proto/connections/cpp/implementation/proto/offline_wire_formats.pb.cc @@ -0,0 +1,9912 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: connections/implementation/proto/offline_wire_formats.proto + +#include "connections/implementation/proto/offline_wire_formats.pb.h" + +#include + +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace location { +namespace nearby { +namespace connections { +constexpr OfflineFrame::OfflineFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : v1_(nullptr) + , version_(0) +{} +struct OfflineFrameDefaultTypeInternal { + constexpr OfflineFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~OfflineFrameDefaultTypeInternal() {} + union { + OfflineFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OfflineFrameDefaultTypeInternal _OfflineFrame_default_instance_; +constexpr V1Frame::V1Frame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : connection_request_(nullptr) + , connection_response_(nullptr) + , payload_transfer_(nullptr) + , bandwidth_upgrade_negotiation_(nullptr) + , keep_alive_(nullptr) + , disconnection_(nullptr) + , paired_key_encryption_(nullptr) + , type_(0) +{} +struct V1FrameDefaultTypeInternal { + constexpr V1FrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~V1FrameDefaultTypeInternal() {} + union { + V1Frame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT V1FrameDefaultTypeInternal _V1Frame_default_instance_; +constexpr ConnectionRequestFrame::ConnectionRequestFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : mediums_() + , endpoint_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , endpoint_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , handshake_data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , endpoint_info_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , device_info_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , medium_metadata_(nullptr) + , nonce_(0) + , keep_alive_interval_millis_(0) + , keep_alive_timeout_millis_(0) + , device_type_(0){} +struct ConnectionRequestFrameDefaultTypeInternal { + constexpr ConnectionRequestFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ConnectionRequestFrameDefaultTypeInternal() {} + union { + ConnectionRequestFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionRequestFrameDefaultTypeInternal _ConnectionRequestFrame_default_instance_; +constexpr ConnectionResponseFrame::ConnectionResponseFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : handshake_data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , status_(0) + , response_(0) +{} +struct ConnectionResponseFrameDefaultTypeInternal { + constexpr ConnectionResponseFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ConnectionResponseFrameDefaultTypeInternal() {} + union { + ConnectionResponseFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionResponseFrameDefaultTypeInternal _ConnectionResponseFrame_default_instance_; +constexpr PayloadTransferFrame_PayloadHeader::PayloadTransferFrame_PayloadHeader( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : file_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , parent_folder_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , id_(int64_t{0}) + , total_size_(int64_t{0}) + , type_(0) + + , is_sensitive_(false){} +struct PayloadTransferFrame_PayloadHeaderDefaultTypeInternal { + constexpr PayloadTransferFrame_PayloadHeaderDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PayloadTransferFrame_PayloadHeaderDefaultTypeInternal() {} + union { + PayloadTransferFrame_PayloadHeader _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PayloadTransferFrame_PayloadHeaderDefaultTypeInternal _PayloadTransferFrame_PayloadHeader_default_instance_; +constexpr PayloadTransferFrame_PayloadChunk::PayloadTransferFrame_PayloadChunk( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : body_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , offset_(int64_t{0}) + , flags_(0){} +struct PayloadTransferFrame_PayloadChunkDefaultTypeInternal { + constexpr PayloadTransferFrame_PayloadChunkDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PayloadTransferFrame_PayloadChunkDefaultTypeInternal() {} + union { + PayloadTransferFrame_PayloadChunk _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PayloadTransferFrame_PayloadChunkDefaultTypeInternal _PayloadTransferFrame_PayloadChunk_default_instance_; +constexpr PayloadTransferFrame_ControlMessage::PayloadTransferFrame_ControlMessage( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : offset_(int64_t{0}) + , event_(0) +{} +struct PayloadTransferFrame_ControlMessageDefaultTypeInternal { + constexpr PayloadTransferFrame_ControlMessageDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PayloadTransferFrame_ControlMessageDefaultTypeInternal() {} + union { + PayloadTransferFrame_ControlMessage _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PayloadTransferFrame_ControlMessageDefaultTypeInternal _PayloadTransferFrame_ControlMessage_default_instance_; +constexpr PayloadTransferFrame::PayloadTransferFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : payload_header_(nullptr) + , payload_chunk_(nullptr) + , control_message_(nullptr) + , packet_type_(0) +{} +struct PayloadTransferFrameDefaultTypeInternal { + constexpr PayloadTransferFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PayloadTransferFrameDefaultTypeInternal() {} + union { + PayloadTransferFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PayloadTransferFrameDefaultTypeInternal _PayloadTransferFrame_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : ssid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , password_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , gateway_(nullptr) + , port_(0) + , frequency_(-1){} +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentialsDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentialsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentialsDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : ip_address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , wifi_port_(0){} +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : service_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , mac_address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentialsDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentialsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentialsDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : service_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , service_info_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , password_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentialsDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentialsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentialsDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : ssid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , password_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , gateway_(nullptr) + , port_(0) + , frequency_(0){} +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentialsDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentialsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentialsDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : peer_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , location_hint_(nullptr){} +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentialsDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentialsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentialsDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo::BandwidthUpgradeNegotiationFrame_UpgradePathInfo( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : wifi_hotspot_credentials_(nullptr) + , wifi_lan_socket_(nullptr) + , bluetooth_credentials_(nullptr) + , wifi_aware_credentials_(nullptr) + , wifi_direct_credentials_(nullptr) + , web_rtc_credentials_(nullptr) + , medium_(0) + + , supports_disabling_encryption_(false) + , supports_client_introduction_ack_(false){} +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfoDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfoDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfoDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrame_UpgradePathInfoDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame_ClientIntroduction::BandwidthUpgradeNegotiationFrame_ClientIntroduction( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : endpoint_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , supports_disabling_encryption_(false){} +struct BandwidthUpgradeNegotiationFrame_ClientIntroductionDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrame_ClientIntroductionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrame_ClientIntroductionDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame_ClientIntroduction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrame_ClientIntroductionDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_ClientIntroduction_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct BandwidthUpgradeNegotiationFrame_ClientIntroductionAckDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrame_ClientIntroductionAckDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrame_ClientIntroductionAckDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame_ClientIntroductionAck _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrame_ClientIntroductionAckDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_ClientIntroductionAck_default_instance_; +constexpr BandwidthUpgradeNegotiationFrame::BandwidthUpgradeNegotiationFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : upgrade_path_info_(nullptr) + , client_introduction_(nullptr) + , client_introduction_ack_(nullptr) + , event_type_(0) +{} +struct BandwidthUpgradeNegotiationFrameDefaultTypeInternal { + constexpr BandwidthUpgradeNegotiationFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~BandwidthUpgradeNegotiationFrameDefaultTypeInternal() {} + union { + BandwidthUpgradeNegotiationFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrameDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_default_instance_; +constexpr KeepAliveFrame::KeepAliveFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : ack_(false){} +struct KeepAliveFrameDefaultTypeInternal { + constexpr KeepAliveFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~KeepAliveFrameDefaultTypeInternal() {} + union { + KeepAliveFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT KeepAliveFrameDefaultTypeInternal _KeepAliveFrame_default_instance_; +constexpr DisconnectionFrame::DisconnectionFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct DisconnectionFrameDefaultTypeInternal { + constexpr DisconnectionFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DisconnectionFrameDefaultTypeInternal() {} + union { + DisconnectionFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DisconnectionFrameDefaultTypeInternal _DisconnectionFrame_default_instance_; +constexpr PairedKeyEncryptionFrame::PairedKeyEncryptionFrame( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : signed_data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct PairedKeyEncryptionFrameDefaultTypeInternal { + constexpr PairedKeyEncryptionFrameDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PairedKeyEncryptionFrameDefaultTypeInternal() {} + union { + PairedKeyEncryptionFrame _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PairedKeyEncryptionFrameDefaultTypeInternal _PairedKeyEncryptionFrame_default_instance_; +constexpr MediumMetadata::MediumMetadata( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : bssid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , ip_address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , available_channels_(nullptr) + , wifi_direct_cli_usable_channels_(nullptr) + , wifi_lan_usable_channels_(nullptr) + , wifi_aware_usable_channels_(nullptr) + , wifi_hotspot_sta_usable_channels_(nullptr) + , supports_5_ghz_(false) + , supports_6_ghz_(false) + , mobile_radio_(false) + , ap_frequency_(-1){} +struct MediumMetadataDefaultTypeInternal { + constexpr MediumMetadataDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MediumMetadataDefaultTypeInternal() {} + union { + MediumMetadata _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MediumMetadataDefaultTypeInternal _MediumMetadata_default_instance_; +constexpr AvailableChannels::AvailableChannels( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : channels_() + , _channels_cached_byte_size_(0){} +struct AvailableChannelsDefaultTypeInternal { + constexpr AvailableChannelsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AvailableChannelsDefaultTypeInternal() {} + union { + AvailableChannels _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AvailableChannelsDefaultTypeInternal _AvailableChannels_default_instance_; +constexpr WifiDirectCliUsableChannels::WifiDirectCliUsableChannels( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : channels_() + , _channels_cached_byte_size_(0){} +struct WifiDirectCliUsableChannelsDefaultTypeInternal { + constexpr WifiDirectCliUsableChannelsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~WifiDirectCliUsableChannelsDefaultTypeInternal() {} + union { + WifiDirectCliUsableChannels _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WifiDirectCliUsableChannelsDefaultTypeInternal _WifiDirectCliUsableChannels_default_instance_; +constexpr WifiLanUsableChannels::WifiLanUsableChannels( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : channels_() + , _channels_cached_byte_size_(0){} +struct WifiLanUsableChannelsDefaultTypeInternal { + constexpr WifiLanUsableChannelsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~WifiLanUsableChannelsDefaultTypeInternal() {} + union { + WifiLanUsableChannels _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WifiLanUsableChannelsDefaultTypeInternal _WifiLanUsableChannels_default_instance_; +constexpr WifiAwareUsableChannels::WifiAwareUsableChannels( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : channels_() + , _channels_cached_byte_size_(0){} +struct WifiAwareUsableChannelsDefaultTypeInternal { + constexpr WifiAwareUsableChannelsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~WifiAwareUsableChannelsDefaultTypeInternal() {} + union { + WifiAwareUsableChannels _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WifiAwareUsableChannelsDefaultTypeInternal _WifiAwareUsableChannels_default_instance_; +constexpr WifiHotspotStaUsableChannels::WifiHotspotStaUsableChannels( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : channels_() + , _channels_cached_byte_size_(0){} +struct WifiHotspotStaUsableChannelsDefaultTypeInternal { + constexpr WifiHotspotStaUsableChannelsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~WifiHotspotStaUsableChannelsDefaultTypeInternal() {} + union { + WifiHotspotStaUsableChannels _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT WifiHotspotStaUsableChannelsDefaultTypeInternal _WifiHotspotStaUsableChannels_default_instance_; +constexpr LocationHint::LocationHint( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : location_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , format_(0) +{} +struct LocationHintDefaultTypeInternal { + constexpr LocationHintDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~LocationHintDefaultTypeInternal() {} + union { + LocationHint _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LocationHintDefaultTypeInternal _LocationHint_default_instance_; +constexpr LocationStandard::LocationStandard( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct LocationStandardDefaultTypeInternal { + constexpr LocationStandardDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~LocationStandardDefaultTypeInternal() {} + union { + LocationStandard _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LocationStandardDefaultTypeInternal _LocationStandard_default_instance_; +} // namespace connections +} // namespace nearby +} // namespace location +namespace location { +namespace nearby { +namespace connections { +bool OfflineFrame_Version_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed OfflineFrame_Version_strings[2] = {}; + +static const char OfflineFrame_Version_names[] = + "UNKNOWN_VERSION" + "V1"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OfflineFrame_Version_entries[] = { + { {OfflineFrame_Version_names + 0, 15}, 0 }, + { {OfflineFrame_Version_names + 15, 2}, 1 }, +}; + +static const int OfflineFrame_Version_entries_by_number[] = { + 0, // 0 -> UNKNOWN_VERSION + 1, // 1 -> V1 +}; + +const std::string& OfflineFrame_Version_Name( + OfflineFrame_Version value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + OfflineFrame_Version_entries, + OfflineFrame_Version_entries_by_number, + 2, OfflineFrame_Version_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + OfflineFrame_Version_entries, + OfflineFrame_Version_entries_by_number, + 2, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + OfflineFrame_Version_strings[idx].get(); +} +bool OfflineFrame_Version_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OfflineFrame_Version* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + OfflineFrame_Version_entries, 2, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr OfflineFrame_Version OfflineFrame::UNKNOWN_VERSION; +constexpr OfflineFrame_Version OfflineFrame::V1; +constexpr OfflineFrame_Version OfflineFrame::Version_MIN; +constexpr OfflineFrame_Version OfflineFrame::Version_MAX; +constexpr int OfflineFrame::Version_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool V1Frame_FrameType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed V1Frame_FrameType_strings[8] = {}; + +static const char V1Frame_FrameType_names[] = + "BANDWIDTH_UPGRADE_NEGOTIATION" + "CONNECTION_REQUEST" + "CONNECTION_RESPONSE" + "DISCONNECTION" + "KEEP_ALIVE" + "PAIRED_KEY_ENCRYPTION" + "PAYLOAD_TRANSFER" + "UNKNOWN_FRAME_TYPE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry V1Frame_FrameType_entries[] = { + { {V1Frame_FrameType_names + 0, 29}, 4 }, + { {V1Frame_FrameType_names + 29, 18}, 1 }, + { {V1Frame_FrameType_names + 47, 19}, 2 }, + { {V1Frame_FrameType_names + 66, 13}, 6 }, + { {V1Frame_FrameType_names + 79, 10}, 5 }, + { {V1Frame_FrameType_names + 89, 21}, 7 }, + { {V1Frame_FrameType_names + 110, 16}, 3 }, + { {V1Frame_FrameType_names + 126, 18}, 0 }, +}; + +static const int V1Frame_FrameType_entries_by_number[] = { + 7, // 0 -> UNKNOWN_FRAME_TYPE + 1, // 1 -> CONNECTION_REQUEST + 2, // 2 -> CONNECTION_RESPONSE + 6, // 3 -> PAYLOAD_TRANSFER + 0, // 4 -> BANDWIDTH_UPGRADE_NEGOTIATION + 4, // 5 -> KEEP_ALIVE + 3, // 6 -> DISCONNECTION + 5, // 7 -> PAIRED_KEY_ENCRYPTION +}; + +const std::string& V1Frame_FrameType_Name( + V1Frame_FrameType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + V1Frame_FrameType_entries, + V1Frame_FrameType_entries_by_number, + 8, V1Frame_FrameType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + V1Frame_FrameType_entries, + V1Frame_FrameType_entries_by_number, + 8, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + V1Frame_FrameType_strings[idx].get(); +} +bool V1Frame_FrameType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1Frame_FrameType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + V1Frame_FrameType_entries, 8, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr V1Frame_FrameType V1Frame::UNKNOWN_FRAME_TYPE; +constexpr V1Frame_FrameType V1Frame::CONNECTION_REQUEST; +constexpr V1Frame_FrameType V1Frame::CONNECTION_RESPONSE; +constexpr V1Frame_FrameType V1Frame::PAYLOAD_TRANSFER; +constexpr V1Frame_FrameType V1Frame::BANDWIDTH_UPGRADE_NEGOTIATION; +constexpr V1Frame_FrameType V1Frame::KEEP_ALIVE; +constexpr V1Frame_FrameType V1Frame::DISCONNECTION; +constexpr V1Frame_FrameType V1Frame::PAIRED_KEY_ENCRYPTION; +constexpr V1Frame_FrameType V1Frame::FrameType_MIN; +constexpr V1Frame_FrameType V1Frame::FrameType_MAX; +constexpr int V1Frame::FrameType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool ConnectionRequestFrame_Medium_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed ConnectionRequestFrame_Medium_strings[12] = {}; + +static const char ConnectionRequestFrame_Medium_names[] = + "BLE" + "BLE_L2CAP" + "BLUETOOTH" + "MDNS" + "NFC" + "UNKNOWN_MEDIUM" + "USB" + "WEB_RTC" + "WIFI_AWARE" + "WIFI_DIRECT" + "WIFI_HOTSPOT" + "WIFI_LAN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConnectionRequestFrame_Medium_entries[] = { + { {ConnectionRequestFrame_Medium_names + 0, 3}, 4 }, + { {ConnectionRequestFrame_Medium_names + 3, 9}, 10 }, + { {ConnectionRequestFrame_Medium_names + 12, 9}, 2 }, + { {ConnectionRequestFrame_Medium_names + 21, 4}, 1 }, + { {ConnectionRequestFrame_Medium_names + 25, 3}, 7 }, + { {ConnectionRequestFrame_Medium_names + 28, 14}, 0 }, + { {ConnectionRequestFrame_Medium_names + 42, 3}, 11 }, + { {ConnectionRequestFrame_Medium_names + 45, 7}, 9 }, + { {ConnectionRequestFrame_Medium_names + 52, 10}, 6 }, + { {ConnectionRequestFrame_Medium_names + 62, 11}, 8 }, + { {ConnectionRequestFrame_Medium_names + 73, 12}, 3 }, + { {ConnectionRequestFrame_Medium_names + 85, 8}, 5 }, +}; + +static const int ConnectionRequestFrame_Medium_entries_by_number[] = { + 5, // 0 -> UNKNOWN_MEDIUM + 3, // 1 -> MDNS + 2, // 2 -> BLUETOOTH + 10, // 3 -> WIFI_HOTSPOT + 0, // 4 -> BLE + 11, // 5 -> WIFI_LAN + 8, // 6 -> WIFI_AWARE + 4, // 7 -> NFC + 9, // 8 -> WIFI_DIRECT + 7, // 9 -> WEB_RTC + 1, // 10 -> BLE_L2CAP + 6, // 11 -> USB +}; + +const std::string& ConnectionRequestFrame_Medium_Name( + ConnectionRequestFrame_Medium value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + ConnectionRequestFrame_Medium_entries, + ConnectionRequestFrame_Medium_entries_by_number, + 12, ConnectionRequestFrame_Medium_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + ConnectionRequestFrame_Medium_entries, + ConnectionRequestFrame_Medium_entries_by_number, + 12, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + ConnectionRequestFrame_Medium_strings[idx].get(); +} +bool ConnectionRequestFrame_Medium_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionRequestFrame_Medium* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + ConnectionRequestFrame_Medium_entries, 12, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::UNKNOWN_MEDIUM; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::MDNS; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::BLUETOOTH; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::WIFI_HOTSPOT; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::BLE; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::WIFI_LAN; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::WIFI_AWARE; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::NFC; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::WIFI_DIRECT; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::WEB_RTC; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::BLE_L2CAP; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::USB; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::Medium_MIN; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame::Medium_MAX; +constexpr int ConnectionRequestFrame::Medium_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool ConnectionResponseFrame_ResponseStatus_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed ConnectionResponseFrame_ResponseStatus_strings[3] = {}; + +static const char ConnectionResponseFrame_ResponseStatus_names[] = + "ACCEPT" + "REJECT" + "UNKNOWN_RESPONSE_STATUS"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConnectionResponseFrame_ResponseStatus_entries[] = { + { {ConnectionResponseFrame_ResponseStatus_names + 0, 6}, 1 }, + { {ConnectionResponseFrame_ResponseStatus_names + 6, 6}, 2 }, + { {ConnectionResponseFrame_ResponseStatus_names + 12, 23}, 0 }, +}; + +static const int ConnectionResponseFrame_ResponseStatus_entries_by_number[] = { + 2, // 0 -> UNKNOWN_RESPONSE_STATUS + 0, // 1 -> ACCEPT + 1, // 2 -> REJECT +}; + +const std::string& ConnectionResponseFrame_ResponseStatus_Name( + ConnectionResponseFrame_ResponseStatus value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + ConnectionResponseFrame_ResponseStatus_entries, + ConnectionResponseFrame_ResponseStatus_entries_by_number, + 3, ConnectionResponseFrame_ResponseStatus_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + ConnectionResponseFrame_ResponseStatus_entries, + ConnectionResponseFrame_ResponseStatus_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + ConnectionResponseFrame_ResponseStatus_strings[idx].get(); +} +bool ConnectionResponseFrame_ResponseStatus_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionResponseFrame_ResponseStatus* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + ConnectionResponseFrame_ResponseStatus_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame::UNKNOWN_RESPONSE_STATUS; +constexpr ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame::ACCEPT; +constexpr ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame::REJECT; +constexpr ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame::ResponseStatus_MIN; +constexpr ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame::ResponseStatus_MAX; +constexpr int ConnectionResponseFrame::ResponseStatus_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool PayloadTransferFrame_PayloadHeader_PayloadType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed PayloadTransferFrame_PayloadHeader_PayloadType_strings[4] = {}; + +static const char PayloadTransferFrame_PayloadHeader_PayloadType_names[] = + "BYTES" + "FILE" + "STREAM" + "UNKNOWN_PAYLOAD_TYPE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PayloadTransferFrame_PayloadHeader_PayloadType_entries[] = { + { {PayloadTransferFrame_PayloadHeader_PayloadType_names + 0, 5}, 1 }, + { {PayloadTransferFrame_PayloadHeader_PayloadType_names + 5, 4}, 2 }, + { {PayloadTransferFrame_PayloadHeader_PayloadType_names + 9, 6}, 3 }, + { {PayloadTransferFrame_PayloadHeader_PayloadType_names + 15, 20}, 0 }, +}; + +static const int PayloadTransferFrame_PayloadHeader_PayloadType_entries_by_number[] = { + 3, // 0 -> UNKNOWN_PAYLOAD_TYPE + 0, // 1 -> BYTES + 1, // 2 -> FILE + 2, // 3 -> STREAM +}; + +const std::string& PayloadTransferFrame_PayloadHeader_PayloadType_Name( + PayloadTransferFrame_PayloadHeader_PayloadType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + PayloadTransferFrame_PayloadHeader_PayloadType_entries, + PayloadTransferFrame_PayloadHeader_PayloadType_entries_by_number, + 4, PayloadTransferFrame_PayloadHeader_PayloadType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + PayloadTransferFrame_PayloadHeader_PayloadType_entries, + PayloadTransferFrame_PayloadHeader_PayloadType_entries_by_number, + 4, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + PayloadTransferFrame_PayloadHeader_PayloadType_strings[idx].get(); +} +bool PayloadTransferFrame_PayloadHeader_PayloadType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_PayloadHeader_PayloadType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + PayloadTransferFrame_PayloadHeader_PayloadType_entries, 4, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader::UNKNOWN_PAYLOAD_TYPE; +constexpr PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader::BYTES; +constexpr PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader::FILE; +constexpr PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader::STREAM; +constexpr PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader::PayloadType_MIN; +constexpr PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader::PayloadType_MAX; +constexpr int PayloadTransferFrame_PayloadHeader::PayloadType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool PayloadTransferFrame_PayloadChunk_Flags_IsValid(int value) { + switch (value) { + case 1: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed PayloadTransferFrame_PayloadChunk_Flags_strings[1] = {}; + +static const char PayloadTransferFrame_PayloadChunk_Flags_names[] = + "LAST_CHUNK"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PayloadTransferFrame_PayloadChunk_Flags_entries[] = { + { {PayloadTransferFrame_PayloadChunk_Flags_names + 0, 10}, 1 }, +}; + +static const int PayloadTransferFrame_PayloadChunk_Flags_entries_by_number[] = { + 0, // 1 -> LAST_CHUNK +}; + +const std::string& PayloadTransferFrame_PayloadChunk_Flags_Name( + PayloadTransferFrame_PayloadChunk_Flags value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + PayloadTransferFrame_PayloadChunk_Flags_entries, + PayloadTransferFrame_PayloadChunk_Flags_entries_by_number, + 1, PayloadTransferFrame_PayloadChunk_Flags_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + PayloadTransferFrame_PayloadChunk_Flags_entries, + PayloadTransferFrame_PayloadChunk_Flags_entries_by_number, + 1, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + PayloadTransferFrame_PayloadChunk_Flags_strings[idx].get(); +} +bool PayloadTransferFrame_PayloadChunk_Flags_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_PayloadChunk_Flags* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + PayloadTransferFrame_PayloadChunk_Flags_entries, 1, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PayloadTransferFrame_PayloadChunk_Flags PayloadTransferFrame_PayloadChunk::LAST_CHUNK; +constexpr PayloadTransferFrame_PayloadChunk_Flags PayloadTransferFrame_PayloadChunk::Flags_MIN; +constexpr PayloadTransferFrame_PayloadChunk_Flags PayloadTransferFrame_PayloadChunk::Flags_MAX; +constexpr int PayloadTransferFrame_PayloadChunk::Flags_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool PayloadTransferFrame_ControlMessage_EventType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed PayloadTransferFrame_ControlMessage_EventType_strings[3] = {}; + +static const char PayloadTransferFrame_ControlMessage_EventType_names[] = + "PAYLOAD_CANCELED" + "PAYLOAD_ERROR" + "UNKNOWN_EVENT_TYPE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PayloadTransferFrame_ControlMessage_EventType_entries[] = { + { {PayloadTransferFrame_ControlMessage_EventType_names + 0, 16}, 2 }, + { {PayloadTransferFrame_ControlMessage_EventType_names + 16, 13}, 1 }, + { {PayloadTransferFrame_ControlMessage_EventType_names + 29, 18}, 0 }, +}; + +static const int PayloadTransferFrame_ControlMessage_EventType_entries_by_number[] = { + 2, // 0 -> UNKNOWN_EVENT_TYPE + 1, // 1 -> PAYLOAD_ERROR + 0, // 2 -> PAYLOAD_CANCELED +}; + +const std::string& PayloadTransferFrame_ControlMessage_EventType_Name( + PayloadTransferFrame_ControlMessage_EventType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + PayloadTransferFrame_ControlMessage_EventType_entries, + PayloadTransferFrame_ControlMessage_EventType_entries_by_number, + 3, PayloadTransferFrame_ControlMessage_EventType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + PayloadTransferFrame_ControlMessage_EventType_entries, + PayloadTransferFrame_ControlMessage_EventType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + PayloadTransferFrame_ControlMessage_EventType_strings[idx].get(); +} +bool PayloadTransferFrame_ControlMessage_EventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_ControlMessage_EventType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + PayloadTransferFrame_ControlMessage_EventType_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage::UNKNOWN_EVENT_TYPE; +constexpr PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage::PAYLOAD_ERROR; +constexpr PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage::PAYLOAD_CANCELED; +constexpr PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage::EventType_MIN; +constexpr PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage::EventType_MAX; +constexpr int PayloadTransferFrame_ControlMessage::EventType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool PayloadTransferFrame_PacketType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed PayloadTransferFrame_PacketType_strings[3] = {}; + +static const char PayloadTransferFrame_PacketType_names[] = + "CONTROL" + "DATA" + "UNKNOWN_PACKET_TYPE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PayloadTransferFrame_PacketType_entries[] = { + { {PayloadTransferFrame_PacketType_names + 0, 7}, 2 }, + { {PayloadTransferFrame_PacketType_names + 7, 4}, 1 }, + { {PayloadTransferFrame_PacketType_names + 11, 19}, 0 }, +}; + +static const int PayloadTransferFrame_PacketType_entries_by_number[] = { + 2, // 0 -> UNKNOWN_PACKET_TYPE + 1, // 1 -> DATA + 0, // 2 -> CONTROL +}; + +const std::string& PayloadTransferFrame_PacketType_Name( + PayloadTransferFrame_PacketType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + PayloadTransferFrame_PacketType_entries, + PayloadTransferFrame_PacketType_entries_by_number, + 3, PayloadTransferFrame_PacketType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + PayloadTransferFrame_PacketType_entries, + PayloadTransferFrame_PacketType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + PayloadTransferFrame_PacketType_strings[idx].get(); +} +bool PayloadTransferFrame_PacketType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_PacketType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + PayloadTransferFrame_PacketType_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::UNKNOWN_PACKET_TYPE; +constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::DATA; +constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::CONTROL; +constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::PacketType_MIN; +constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::PacketType_MAX; +constexpr int PayloadTransferFrame::PacketType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 11: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_strings[11] = {}; + +static const char BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names[] = + "BLE" + "BLUETOOTH" + "MDNS" + "NFC" + "UNKNOWN_MEDIUM" + "USB" + "WEB_RTC" + "WIFI_AWARE" + "WIFI_DIRECT" + "WIFI_HOTSPOT" + "WIFI_LAN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_entries[] = { + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 0, 3}, 4 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 3, 9}, 2 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 12, 4}, 1 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 16, 3}, 7 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 19, 14}, 0 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 33, 3}, 11 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 36, 7}, 9 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 43, 10}, 6 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 53, 11}, 8 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 64, 12}, 3 }, + { {BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_names + 76, 8}, 5 }, +}; + +static const int BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_entries_by_number[] = { + 4, // 0 -> UNKNOWN_MEDIUM + 2, // 1 -> MDNS + 1, // 2 -> BLUETOOTH + 9, // 3 -> WIFI_HOTSPOT + 0, // 4 -> BLE + 10, // 5 -> WIFI_LAN + 7, // 6 -> WIFI_AWARE + 3, // 7 -> NFC + 8, // 8 -> WIFI_DIRECT + 6, // 9 -> WEB_RTC + 5, // 11 -> USB +}; + +const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Name( + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_entries, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_entries_by_number, + 11, BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_entries, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_entries_by_number, + 11, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_strings[idx].get(); +} +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_entries, 11, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::UNKNOWN_MEDIUM; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::MDNS; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::BLUETOOTH; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::WIFI_HOTSPOT; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::BLE; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::WIFI_LAN; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::WIFI_AWARE; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::NFC; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::WIFI_DIRECT; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::WEB_RTC; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::USB; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::Medium_MIN; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::Medium_MAX; +constexpr int BandwidthUpgradeNegotiationFrame_UpgradePathInfo::Medium_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool BandwidthUpgradeNegotiationFrame_EventType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed BandwidthUpgradeNegotiationFrame_EventType_strings[7] = {}; + +static const char BandwidthUpgradeNegotiationFrame_EventType_names[] = + "CLIENT_INTRODUCTION" + "CLIENT_INTRODUCTION_ACK" + "LAST_WRITE_TO_PRIOR_CHANNEL" + "SAFE_TO_CLOSE_PRIOR_CHANNEL" + "UNKNOWN_EVENT_TYPE" + "UPGRADE_FAILURE" + "UPGRADE_PATH_AVAILABLE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BandwidthUpgradeNegotiationFrame_EventType_entries[] = { + { {BandwidthUpgradeNegotiationFrame_EventType_names + 0, 19}, 4 }, + { {BandwidthUpgradeNegotiationFrame_EventType_names + 19, 23}, 6 }, + { {BandwidthUpgradeNegotiationFrame_EventType_names + 42, 27}, 2 }, + { {BandwidthUpgradeNegotiationFrame_EventType_names + 69, 27}, 3 }, + { {BandwidthUpgradeNegotiationFrame_EventType_names + 96, 18}, 0 }, + { {BandwidthUpgradeNegotiationFrame_EventType_names + 114, 15}, 5 }, + { {BandwidthUpgradeNegotiationFrame_EventType_names + 129, 22}, 1 }, +}; + +static const int BandwidthUpgradeNegotiationFrame_EventType_entries_by_number[] = { + 4, // 0 -> UNKNOWN_EVENT_TYPE + 6, // 1 -> UPGRADE_PATH_AVAILABLE + 2, // 2 -> LAST_WRITE_TO_PRIOR_CHANNEL + 3, // 3 -> SAFE_TO_CLOSE_PRIOR_CHANNEL + 0, // 4 -> CLIENT_INTRODUCTION + 5, // 5 -> UPGRADE_FAILURE + 1, // 6 -> CLIENT_INTRODUCTION_ACK +}; + +const std::string& BandwidthUpgradeNegotiationFrame_EventType_Name( + BandwidthUpgradeNegotiationFrame_EventType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + BandwidthUpgradeNegotiationFrame_EventType_entries, + BandwidthUpgradeNegotiationFrame_EventType_entries_by_number, + 7, BandwidthUpgradeNegotiationFrame_EventType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + BandwidthUpgradeNegotiationFrame_EventType_entries, + BandwidthUpgradeNegotiationFrame_EventType_entries_by_number, + 7, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + BandwidthUpgradeNegotiationFrame_EventType_strings[idx].get(); +} +bool BandwidthUpgradeNegotiationFrame_EventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeNegotiationFrame_EventType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + BandwidthUpgradeNegotiationFrame_EventType_entries, 7, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::UNKNOWN_EVENT_TYPE; +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::UPGRADE_PATH_AVAILABLE; +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::LAST_WRITE_TO_PRIOR_CHANNEL; +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::SAFE_TO_CLOSE_PRIOR_CHANNEL; +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::CLIENT_INTRODUCTION; +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::UPGRADE_FAILURE; +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::CLIENT_INTRODUCTION_ACK; +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::EventType_MIN; +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::EventType_MAX; +constexpr int BandwidthUpgradeNegotiationFrame::EventType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool LocationStandard_Format_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed LocationStandard_Format_strings[3] = {}; + +static const char LocationStandard_Format_names[] = + "E164_CALLING" + "ISO_3166_1_ALPHA_2" + "UNKNOWN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry LocationStandard_Format_entries[] = { + { {LocationStandard_Format_names + 0, 12}, 1 }, + { {LocationStandard_Format_names + 12, 18}, 2 }, + { {LocationStandard_Format_names + 30, 7}, 0 }, +}; + +static const int LocationStandard_Format_entries_by_number[] = { + 2, // 0 -> UNKNOWN + 0, // 1 -> E164_CALLING + 1, // 2 -> ISO_3166_1_ALPHA_2 +}; + +const std::string& LocationStandard_Format_Name( + LocationStandard_Format value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + LocationStandard_Format_entries, + LocationStandard_Format_entries_by_number, + 3, LocationStandard_Format_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + LocationStandard_Format_entries, + LocationStandard_Format_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + LocationStandard_Format_strings[idx].get(); +} +bool LocationStandard_Format_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LocationStandard_Format* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + LocationStandard_Format_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr LocationStandard_Format LocationStandard::UNKNOWN; +constexpr LocationStandard_Format LocationStandard::E164_CALLING; +constexpr LocationStandard_Format LocationStandard::ISO_3166_1_ALPHA_2; +constexpr LocationStandard_Format LocationStandard::Format_MIN; +constexpr LocationStandard_Format LocationStandard::Format_MAX; +constexpr int LocationStandard::Format_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) + +// =================================================================== + +class OfflineFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_version(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::location::nearby::connections::V1Frame& v1(const OfflineFrame* msg); + static void set_has_v1(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +const ::location::nearby::connections::V1Frame& +OfflineFrame::_Internal::v1(const OfflineFrame* msg) { + return *msg->v1_; +} +OfflineFrame::OfflineFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.OfflineFrame) +} +OfflineFrame::OfflineFrame(const OfflineFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_v1()) { + v1_ = new ::location::nearby::connections::V1Frame(*from.v1_); + } else { + v1_ = nullptr; + } + version_ = from.version_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.OfflineFrame) +} + +inline void OfflineFrame::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&v1_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&version_) - + reinterpret_cast(&v1_)) + sizeof(version_)); +} + +OfflineFrame::~OfflineFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.OfflineFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void OfflineFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete v1_; +} + +void OfflineFrame::ArenaDtor(void* object) { + OfflineFrame* _this = reinterpret_cast< OfflineFrame* >(object); + (void)_this; +} +void OfflineFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void OfflineFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void OfflineFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.OfflineFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(v1_ != nullptr); + v1_->Clear(); + } + version_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* OfflineFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .location.nearby.connections.OfflineFrame.Version version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::OfflineFrame_Version_IsValid(val))) { + _internal_set_version(static_cast<::location::nearby::connections::OfflineFrame_Version>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.V1Frame v1 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_v1(), 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(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* OfflineFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.OfflineFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.connections.OfflineFrame.Version version = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_version(), target); + } + + // optional .location.nearby.connections.V1Frame v1 = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::v1(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.OfflineFrame) + return target; +} + +size_t OfflineFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.OfflineFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .location.nearby.connections.V1Frame v1 = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *v1_); + } + + // optional .location.nearby.connections.OfflineFrame.Version version = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_version()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void OfflineFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void OfflineFrame::MergeFrom(const OfflineFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.OfflineFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_v1()->::location::nearby::connections::V1Frame::MergeFrom(from._internal_v1()); + } + if (cached_has_bits & 0x00000002u) { + version_ = from.version_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void OfflineFrame::CopyFrom(const OfflineFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.OfflineFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool OfflineFrame::IsInitialized() const { + return true; +} + +void OfflineFrame::InternalSwap(OfflineFrame* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(OfflineFrame, version_) + + sizeof(OfflineFrame::version_) + - PROTOBUF_FIELD_OFFSET(OfflineFrame, v1_)>( + reinterpret_cast(&v1_), + reinterpret_cast(&other->v1_)); +} + +std::string OfflineFrame::GetTypeName() const { + return "location.nearby.connections.OfflineFrame"; +} + + +// =================================================================== + +class V1Frame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::location::nearby::connections::ConnectionRequestFrame& connection_request(const V1Frame* msg); + static void set_has_connection_request(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::location::nearby::connections::ConnectionResponseFrame& connection_response(const V1Frame* msg); + static void set_has_connection_response(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::location::nearby::connections::PayloadTransferFrame& payload_transfer(const V1Frame* msg); + static void set_has_payload_transfer(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame& bandwidth_upgrade_negotiation(const V1Frame* msg); + static void set_has_bandwidth_upgrade_negotiation(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::location::nearby::connections::KeepAliveFrame& keep_alive(const V1Frame* msg); + static void set_has_keep_alive(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::location::nearby::connections::DisconnectionFrame& disconnection(const V1Frame* msg); + static void set_has_disconnection(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::location::nearby::connections::PairedKeyEncryptionFrame& paired_key_encryption(const V1Frame* msg); + static void set_has_paired_key_encryption(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +const ::location::nearby::connections::ConnectionRequestFrame& +V1Frame::_Internal::connection_request(const V1Frame* msg) { + return *msg->connection_request_; +} +const ::location::nearby::connections::ConnectionResponseFrame& +V1Frame::_Internal::connection_response(const V1Frame* msg) { + return *msg->connection_response_; +} +const ::location::nearby::connections::PayloadTransferFrame& +V1Frame::_Internal::payload_transfer(const V1Frame* msg) { + return *msg->payload_transfer_; +} +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame& +V1Frame::_Internal::bandwidth_upgrade_negotiation(const V1Frame* msg) { + return *msg->bandwidth_upgrade_negotiation_; +} +const ::location::nearby::connections::KeepAliveFrame& +V1Frame::_Internal::keep_alive(const V1Frame* msg) { + return *msg->keep_alive_; +} +const ::location::nearby::connections::DisconnectionFrame& +V1Frame::_Internal::disconnection(const V1Frame* msg) { + return *msg->disconnection_; +} +const ::location::nearby::connections::PairedKeyEncryptionFrame& +V1Frame::_Internal::paired_key_encryption(const V1Frame* msg) { + return *msg->paired_key_encryption_; +} +V1Frame::V1Frame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.V1Frame) +} +V1Frame::V1Frame(const V1Frame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_connection_request()) { + connection_request_ = new ::location::nearby::connections::ConnectionRequestFrame(*from.connection_request_); + } else { + connection_request_ = nullptr; + } + if (from._internal_has_connection_response()) { + connection_response_ = new ::location::nearby::connections::ConnectionResponseFrame(*from.connection_response_); + } else { + connection_response_ = nullptr; + } + if (from._internal_has_payload_transfer()) { + payload_transfer_ = new ::location::nearby::connections::PayloadTransferFrame(*from.payload_transfer_); + } else { + payload_transfer_ = nullptr; + } + if (from._internal_has_bandwidth_upgrade_negotiation()) { + bandwidth_upgrade_negotiation_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame(*from.bandwidth_upgrade_negotiation_); + } else { + bandwidth_upgrade_negotiation_ = nullptr; + } + if (from._internal_has_keep_alive()) { + keep_alive_ = new ::location::nearby::connections::KeepAliveFrame(*from.keep_alive_); + } else { + keep_alive_ = nullptr; + } + if (from._internal_has_disconnection()) { + disconnection_ = new ::location::nearby::connections::DisconnectionFrame(*from.disconnection_); + } else { + disconnection_ = nullptr; + } + if (from._internal_has_paired_key_encryption()) { + paired_key_encryption_ = new ::location::nearby::connections::PairedKeyEncryptionFrame(*from.paired_key_encryption_); + } else { + paired_key_encryption_ = nullptr; + } + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.V1Frame) +} + +inline void V1Frame::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&connection_request_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&connection_request_)) + sizeof(type_)); +} + +V1Frame::~V1Frame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.V1Frame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void V1Frame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete connection_request_; + if (this != internal_default_instance()) delete connection_response_; + if (this != internal_default_instance()) delete payload_transfer_; + if (this != internal_default_instance()) delete bandwidth_upgrade_negotiation_; + if (this != internal_default_instance()) delete keep_alive_; + if (this != internal_default_instance()) delete disconnection_; + if (this != internal_default_instance()) delete paired_key_encryption_; +} + +void V1Frame::ArenaDtor(void* object) { + V1Frame* _this = reinterpret_cast< V1Frame* >(object); + (void)_this; +} +void V1Frame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void V1Frame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void V1Frame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.V1Frame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(connection_request_ != nullptr); + connection_request_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(connection_response_ != nullptr); + connection_response_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(payload_transfer_ != nullptr); + payload_transfer_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(bandwidth_upgrade_negotiation_ != nullptr); + bandwidth_upgrade_negotiation_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(keep_alive_ != nullptr); + keep_alive_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(disconnection_ != nullptr); + disconnection_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(paired_key_encryption_ != nullptr); + paired_key_encryption_->Clear(); + } + } + type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* V1Frame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .location.nearby.connections.V1Frame.FrameType type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::V1Frame_FrameType_IsValid(val))) { + _internal_set_type(static_cast<::location::nearby::connections::V1Frame_FrameType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.ConnectionRequestFrame connection_request = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_connection_request(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.ConnectionResponseFrame connection_response = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_connection_response(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.PayloadTransferFrame payload_transfer = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_payload_transfer(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame bandwidth_upgrade_negotiation = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_bandwidth_upgrade_negotiation(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.KeepAliveFrame keep_alive = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_keep_alive(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.DisconnectionFrame disconnection = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_disconnection(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.PairedKeyEncryptionFrame paired_key_encryption = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_paired_key_encryption(), 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(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* V1Frame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.V1Frame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.connections.V1Frame.FrameType type = 1; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_type(), target); + } + + // optional .location.nearby.connections.ConnectionRequestFrame connection_request = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::connection_request(this), target, stream); + } + + // optional .location.nearby.connections.ConnectionResponseFrame connection_response = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::connection_response(this), target, stream); + } + + // optional .location.nearby.connections.PayloadTransferFrame payload_transfer = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::payload_transfer(this), target, stream); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame bandwidth_upgrade_negotiation = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::bandwidth_upgrade_negotiation(this), target, stream); + } + + // optional .location.nearby.connections.KeepAliveFrame keep_alive = 6; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::keep_alive(this), target, stream); + } + + // optional .location.nearby.connections.DisconnectionFrame disconnection = 7; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::disconnection(this), target, stream); + } + + // optional .location.nearby.connections.PairedKeyEncryptionFrame paired_key_encryption = 8; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::paired_key_encryption(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.V1Frame) + return target; +} + +size_t V1Frame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.V1Frame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .location.nearby.connections.ConnectionRequestFrame connection_request = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *connection_request_); + } + + // optional .location.nearby.connections.ConnectionResponseFrame connection_response = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *connection_response_); + } + + // optional .location.nearby.connections.PayloadTransferFrame payload_transfer = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *payload_transfer_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame bandwidth_upgrade_negotiation = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bandwidth_upgrade_negotiation_); + } + + // optional .location.nearby.connections.KeepAliveFrame keep_alive = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *keep_alive_); + } + + // optional .location.nearby.connections.DisconnectionFrame disconnection = 7; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *disconnection_); + } + + // optional .location.nearby.connections.PairedKeyEncryptionFrame paired_key_encryption = 8; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *paired_key_encryption_); + } + + // optional .location.nearby.connections.V1Frame.FrameType type = 1; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void V1Frame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void V1Frame::MergeFrom(const V1Frame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.V1Frame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_connection_request()->::location::nearby::connections::ConnectionRequestFrame::MergeFrom(from._internal_connection_request()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_connection_response()->::location::nearby::connections::ConnectionResponseFrame::MergeFrom(from._internal_connection_response()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_payload_transfer()->::location::nearby::connections::PayloadTransferFrame::MergeFrom(from._internal_payload_transfer()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_bandwidth_upgrade_negotiation()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame::MergeFrom(from._internal_bandwidth_upgrade_negotiation()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_keep_alive()->::location::nearby::connections::KeepAliveFrame::MergeFrom(from._internal_keep_alive()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_disconnection()->::location::nearby::connections::DisconnectionFrame::MergeFrom(from._internal_disconnection()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_paired_key_encryption()->::location::nearby::connections::PairedKeyEncryptionFrame::MergeFrom(from._internal_paired_key_encryption()); + } + if (cached_has_bits & 0x00000080u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void V1Frame::CopyFrom(const V1Frame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.V1Frame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool V1Frame::IsInitialized() const { + return true; +} + +void V1Frame::InternalSwap(V1Frame* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(V1Frame, type_) + + sizeof(V1Frame::type_) + - PROTOBUF_FIELD_OFFSET(V1Frame, connection_request_)>( + reinterpret_cast(&connection_request_), + reinterpret_cast(&other->connection_request_)); +} + +std::string V1Frame::GetTypeName() const { + return "location.nearby.connections.V1Frame"; +} + + +// =================================================================== + +class ConnectionRequestFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_endpoint_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_endpoint_name(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_handshake_data(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_nonce(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_endpoint_info(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::location::nearby::connections::MediumMetadata& medium_metadata(const ConnectionRequestFrame* msg); + static void set_has_medium_metadata(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_keep_alive_interval_millis(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_keep_alive_timeout_millis(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_device_type(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_device_info(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +const ::location::nearby::connections::MediumMetadata& +ConnectionRequestFrame::_Internal::medium_metadata(const ConnectionRequestFrame* msg) { + return *msg->medium_metadata_; +} +ConnectionRequestFrame::ConnectionRequestFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + mediums_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.ConnectionRequestFrame) +} +ConnectionRequestFrame::ConnectionRequestFrame(const ConnectionRequestFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + mediums_(from.mediums_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + endpoint_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_endpoint_id()) { + endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_endpoint_id(), + GetArenaForAllocation()); + } + endpoint_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_endpoint_name()) { + endpoint_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_endpoint_name(), + GetArenaForAllocation()); + } + handshake_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + handshake_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_handshake_data()) { + handshake_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_handshake_data(), + GetArenaForAllocation()); + } + endpoint_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_endpoint_info()) { + endpoint_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_endpoint_info(), + GetArenaForAllocation()); + } + device_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + device_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_device_info()) { + device_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_device_info(), + GetArenaForAllocation()); + } + if (from._internal_has_medium_metadata()) { + medium_metadata_ = new ::location::nearby::connections::MediumMetadata(*from.medium_metadata_); + } else { + medium_metadata_ = nullptr; + } + ::memcpy(&nonce_, &from.nonce_, + static_cast(reinterpret_cast(&device_type_) - + reinterpret_cast(&nonce_)) + sizeof(device_type_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.ConnectionRequestFrame) +} + +inline void ConnectionRequestFrame::SharedCtor() { +endpoint_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +endpoint_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +handshake_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + handshake_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +endpoint_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +device_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + device_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&medium_metadata_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&device_type_) - + reinterpret_cast(&medium_metadata_)) + sizeof(device_type_)); +} + +ConnectionRequestFrame::~ConnectionRequestFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.ConnectionRequestFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void ConnectionRequestFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + endpoint_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + endpoint_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + handshake_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + endpoint_info_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + device_info_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete medium_metadata_; +} + +void ConnectionRequestFrame::ArenaDtor(void* object) { + ConnectionRequestFrame* _this = reinterpret_cast< ConnectionRequestFrame* >(object); + (void)_this; +} +void ConnectionRequestFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ConnectionRequestFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ConnectionRequestFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.ConnectionRequestFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + mediums_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + endpoint_id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + endpoint_name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + handshake_data_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + endpoint_info_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + device_info_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(medium_metadata_ != nullptr); + medium_metadata_->Clear(); + } + } + if (cached_has_bits & 0x000000c0u) { + ::memset(&nonce_, 0, static_cast( + reinterpret_cast(&keep_alive_interval_millis_) - + reinterpret_cast(&nonce_)) + sizeof(keep_alive_interval_millis_)); + } + if (cached_has_bits & 0x00000300u) { + ::memset(&keep_alive_timeout_millis_, 0, static_cast( + reinterpret_cast(&device_type_) - + reinterpret_cast(&keep_alive_timeout_millis_)) + sizeof(device_type_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ConnectionRequestFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string endpoint_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_endpoint_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string endpoint_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_endpoint_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes handshake_data = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_handshake_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 nonce = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_nonce(&has_bits); + nonce_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .location.nearby.connections.ConnectionRequestFrame.Medium mediums = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + ptr -= 1; + do { + ptr += 1; + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::ConnectionRequestFrame_Medium_IsValid(val))) { + _internal_add_mediums(static_cast<::location::nearby::connections::ConnectionRequestFrame_Medium>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields()); + } + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<40>(ptr)); + } else if (static_cast(tag) == 42) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_mediums(), ptr, ctx, ::location::nearby::connections::ConnectionRequestFrame_Medium_IsValid, &_internal_metadata_, 5); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes endpoint_info = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_endpoint_info(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.MediumMetadata medium_metadata = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_medium_metadata(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 keep_alive_interval_millis = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_keep_alive_interval_millis(&has_bits); + keep_alive_interval_millis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 keep_alive_timeout_millis = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_keep_alive_timeout_millis(&has_bits); + keep_alive_timeout_millis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 device_type = 10 [default = 0]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_device_type(&has_bits); + device_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes device_info = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_device_info(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ConnectionRequestFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.ConnectionRequestFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string endpoint_id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_endpoint_id(), target); + } + + // optional string endpoint_name = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 2, this->_internal_endpoint_name(), target); + } + + // optional bytes handshake_data = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_handshake_data(), target); + } + + // optional int32 nonce = 4; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_nonce(), target); + } + + // repeated .location.nearby.connections.ConnectionRequestFrame.Medium mediums = 5; + for (int i = 0, n = this->_internal_mediums_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 5, this->_internal_mediums(i), target); + } + + // optional bytes endpoint_info = 6; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteBytesMaybeAliased( + 6, this->_internal_endpoint_info(), target); + } + + // optional .location.nearby.connections.MediumMetadata medium_metadata = 7; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::medium_metadata(this), target, stream); + } + + // optional int32 keep_alive_interval_millis = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(8, this->_internal_keep_alive_interval_millis(), target); + } + + // optional int32 keep_alive_timeout_millis = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(9, this->_internal_keep_alive_timeout_millis(), target); + } + + // optional int32 device_type = 10 [default = 0]; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(10, this->_internal_device_type(), target); + } + + // optional bytes device_info = 11; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteBytesMaybeAliased( + 11, this->_internal_device_info(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.ConnectionRequestFrame) + return target; +} + +size_t ConnectionRequestFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.ConnectionRequestFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .location.nearby.connections.ConnectionRequestFrame.Medium mediums = 5; + { + size_t data_size = 0; + unsigned int count = static_cast(this->_internal_mediums_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize( + this->_internal_mediums(static_cast(i))); + } + total_size += (1UL * count) + data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string endpoint_id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_endpoint_id()); + } + + // optional string endpoint_name = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_endpoint_name()); + } + + // optional bytes handshake_data = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_handshake_data()); + } + + // optional bytes endpoint_info = 6; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_endpoint_info()); + } + + // optional bytes device_info = 11; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_device_info()); + } + + // optional .location.nearby.connections.MediumMetadata medium_metadata = 7; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *medium_metadata_); + } + + // optional int32 nonce = 4; + if (cached_has_bits & 0x00000040u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_nonce()); + } + + // optional int32 keep_alive_interval_millis = 8; + if (cached_has_bits & 0x00000080u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_keep_alive_interval_millis()); + } + + } + if (cached_has_bits & 0x00000300u) { + // optional int32 keep_alive_timeout_millis = 9; + if (cached_has_bits & 0x00000100u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_keep_alive_timeout_millis()); + } + + // optional int32 device_type = 10 [default = 0]; + if (cached_has_bits & 0x00000200u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_device_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ConnectionRequestFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void ConnectionRequestFrame::MergeFrom(const ConnectionRequestFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.ConnectionRequestFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + mediums_.MergeFrom(from.mediums_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_endpoint_id(from._internal_endpoint_id()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_endpoint_name(from._internal_endpoint_name()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_handshake_data(from._internal_handshake_data()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_endpoint_info(from._internal_endpoint_info()); + } + if (cached_has_bits & 0x00000010u) { + _internal_set_device_info(from._internal_device_info()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_medium_metadata()->::location::nearby::connections::MediumMetadata::MergeFrom(from._internal_medium_metadata()); + } + if (cached_has_bits & 0x00000040u) { + nonce_ = from.nonce_; + } + if (cached_has_bits & 0x00000080u) { + keep_alive_interval_millis_ = from.keep_alive_interval_millis_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + keep_alive_timeout_millis_ = from.keep_alive_timeout_millis_; + } + if (cached_has_bits & 0x00000200u) { + device_type_ = from.device_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ConnectionRequestFrame::CopyFrom(const ConnectionRequestFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.ConnectionRequestFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ConnectionRequestFrame::IsInitialized() const { + return true; +} + +void ConnectionRequestFrame::InternalSwap(ConnectionRequestFrame* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + mediums_.InternalSwap(&other->mediums_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &endpoint_id_, lhs_arena, + &other->endpoint_id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &endpoint_name_, lhs_arena, + &other->endpoint_name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &handshake_data_, lhs_arena, + &other->handshake_data_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &endpoint_info_, lhs_arena, + &other->endpoint_info_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &device_info_, lhs_arena, + &other->device_info_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ConnectionRequestFrame, device_type_) + + sizeof(ConnectionRequestFrame::device_type_) + - PROTOBUF_FIELD_OFFSET(ConnectionRequestFrame, medium_metadata_)>( + reinterpret_cast(&medium_metadata_), + reinterpret_cast(&other->medium_metadata_)); +} + +std::string ConnectionRequestFrame::GetTypeName() const { + return "location.nearby.connections.ConnectionRequestFrame"; +} + + +// =================================================================== + +class ConnectionResponseFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_status(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_handshake_data(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_response(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +ConnectionResponseFrame::ConnectionResponseFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.ConnectionResponseFrame) +} +ConnectionResponseFrame::ConnectionResponseFrame(const ConnectionResponseFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + handshake_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + handshake_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_handshake_data()) { + handshake_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_handshake_data(), + GetArenaForAllocation()); + } + ::memcpy(&status_, &from.status_, + static_cast(reinterpret_cast(&response_) - + reinterpret_cast(&status_)) + sizeof(response_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.ConnectionResponseFrame) +} + +inline void ConnectionResponseFrame::SharedCtor() { +handshake_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + handshake_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&status_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&response_) - + reinterpret_cast(&status_)) + sizeof(response_)); +} + +ConnectionResponseFrame::~ConnectionResponseFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.ConnectionResponseFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void ConnectionResponseFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + handshake_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ConnectionResponseFrame::ArenaDtor(void* object) { + ConnectionResponseFrame* _this = reinterpret_cast< ConnectionResponseFrame* >(object); + (void)_this; +} +void ConnectionResponseFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ConnectionResponseFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ConnectionResponseFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.ConnectionResponseFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + handshake_data_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&status_, 0, static_cast( + reinterpret_cast(&response_) - + reinterpret_cast(&status_)) + sizeof(response_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ConnectionResponseFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 status = 1 [deprecated = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_status(&has_bits); + status_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes handshake_data = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_handshake_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.ConnectionResponseFrame.ResponseStatus response = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::ConnectionResponseFrame_ResponseStatus_IsValid(val))) { + _internal_set_response(static_cast<::location::nearby::connections::ConnectionResponseFrame_ResponseStatus>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields()); + } + } 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(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* ConnectionResponseFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.ConnectionResponseFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 status = 1 [deprecated = true]; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_status(), target); + } + + // optional bytes handshake_data = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_handshake_data(), target); + } + + // optional .location.nearby.connections.ConnectionResponseFrame.ResponseStatus response = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_response(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.ConnectionResponseFrame) + return target; +} + +size_t ConnectionResponseFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.ConnectionResponseFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes handshake_data = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_handshake_data()); + } + + // optional int32 status = 1 [deprecated = true]; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_status()); + } + + // optional .location.nearby.connections.ConnectionResponseFrame.ResponseStatus response = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_response()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ConnectionResponseFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void ConnectionResponseFrame::MergeFrom(const ConnectionResponseFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.ConnectionResponseFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_handshake_data(from._internal_handshake_data()); + } + if (cached_has_bits & 0x00000002u) { + status_ = from.status_; + } + if (cached_has_bits & 0x00000004u) { + response_ = from.response_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ConnectionResponseFrame::CopyFrom(const ConnectionResponseFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.ConnectionResponseFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ConnectionResponseFrame::IsInitialized() const { + return true; +} + +void ConnectionResponseFrame::InternalSwap(ConnectionResponseFrame* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &handshake_data_, lhs_arena, + &other->handshake_data_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ConnectionResponseFrame, response_) + + sizeof(ConnectionResponseFrame::response_) + - PROTOBUF_FIELD_OFFSET(ConnectionResponseFrame, status_)>( + reinterpret_cast(&status_), + reinterpret_cast(&other->status_)); +} + +std::string ConnectionResponseFrame::GetTypeName() const { + return "location.nearby.connections.ConnectionResponseFrame"; +} + + +// =================================================================== + +class PayloadTransferFrame_PayloadHeader::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_id(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_total_size(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_is_sensitive(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_file_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_parent_folder(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +PayloadTransferFrame_PayloadHeader::PayloadTransferFrame_PayloadHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.PayloadTransferFrame.PayloadHeader) +} +PayloadTransferFrame_PayloadHeader::PayloadTransferFrame_PayloadHeader(const PayloadTransferFrame_PayloadHeader& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_file_name()) { + file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_file_name(), + GetArenaForAllocation()); + } + parent_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + parent_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_parent_folder()) { + parent_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_parent_folder(), + GetArenaForAllocation()); + } + ::memcpy(&id_, &from.id_, + static_cast(reinterpret_cast(&is_sensitive_) - + reinterpret_cast(&id_)) + sizeof(is_sensitive_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.PayloadTransferFrame.PayloadHeader) +} + +inline void PayloadTransferFrame_PayloadHeader::SharedCtor() { +file_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +parent_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + parent_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&is_sensitive_) - + reinterpret_cast(&id_)) + sizeof(is_sensitive_)); +} + +PayloadTransferFrame_PayloadHeader::~PayloadTransferFrame_PayloadHeader() { + // @@protoc_insertion_point(destructor:location.nearby.connections.PayloadTransferFrame.PayloadHeader) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void PayloadTransferFrame_PayloadHeader::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + file_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + parent_folder_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void PayloadTransferFrame_PayloadHeader::ArenaDtor(void* object) { + PayloadTransferFrame_PayloadHeader* _this = reinterpret_cast< PayloadTransferFrame_PayloadHeader* >(object); + (void)_this; +} +void PayloadTransferFrame_PayloadHeader::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PayloadTransferFrame_PayloadHeader::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PayloadTransferFrame_PayloadHeader::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.PayloadTransferFrame.PayloadHeader) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + file_name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + parent_folder_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000003cu) { + ::memset(&id_, 0, static_cast( + reinterpret_cast(&is_sensitive_) - + reinterpret_cast(&id_)) + sizeof(is_sensitive_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* PayloadTransferFrame_PayloadHeader::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int64 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_id(&has_bits); + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader.PayloadType type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType_IsValid(val))) { + _internal_set_type(static_cast<::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int64 total_size = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_total_size(&has_bits); + total_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool is_sensitive = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_is_sensitive(&has_bits); + is_sensitive_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string file_name = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_file_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string parent_folder = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_parent_folder(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PayloadTransferFrame_PayloadHeader::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.PayloadTransferFrame.PayloadHeader) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int64 id = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_id(), target); + } + + // optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader.PayloadType type = 2; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_type(), target); + } + + // optional int64 total_size = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_total_size(), target); + } + + // optional bool is_sensitive = 4; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_is_sensitive(), target); + } + + // optional string file_name = 5; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 5, this->_internal_file_name(), target); + } + + // optional string parent_folder = 6; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 6, this->_internal_parent_folder(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.PayloadTransferFrame.PayloadHeader) + return target; +} + +size_t PayloadTransferFrame_PayloadHeader::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.PayloadTransferFrame.PayloadHeader) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional string file_name = 5; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_file_name()); + } + + // optional string parent_folder = 6; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_parent_folder()); + } + + // optional int64 id = 1; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_id()); + } + + // optional int64 total_size = 3; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_total_size()); + } + + // optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader.PayloadType type = 2; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + // optional bool is_sensitive = 4; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PayloadTransferFrame_PayloadHeader::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void PayloadTransferFrame_PayloadHeader::MergeFrom(const PayloadTransferFrame_PayloadHeader& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.PayloadTransferFrame.PayloadHeader) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_file_name(from._internal_file_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_parent_folder(from._internal_parent_folder()); + } + if (cached_has_bits & 0x00000004u) { + id_ = from.id_; + } + if (cached_has_bits & 0x00000008u) { + total_size_ = from.total_size_; + } + if (cached_has_bits & 0x00000010u) { + type_ = from.type_; + } + if (cached_has_bits & 0x00000020u) { + is_sensitive_ = from.is_sensitive_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void PayloadTransferFrame_PayloadHeader::CopyFrom(const PayloadTransferFrame_PayloadHeader& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.PayloadTransferFrame.PayloadHeader) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PayloadTransferFrame_PayloadHeader::IsInitialized() const { + return true; +} + +void PayloadTransferFrame_PayloadHeader::InternalSwap(PayloadTransferFrame_PayloadHeader* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &file_name_, lhs_arena, + &other->file_name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &parent_folder_, lhs_arena, + &other->parent_folder_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PayloadTransferFrame_PayloadHeader, is_sensitive_) + + sizeof(PayloadTransferFrame_PayloadHeader::is_sensitive_) + - PROTOBUF_FIELD_OFFSET(PayloadTransferFrame_PayloadHeader, id_)>( + reinterpret_cast(&id_), + reinterpret_cast(&other->id_)); +} + +std::string PayloadTransferFrame_PayloadHeader::GetTypeName() const { + return "location.nearby.connections.PayloadTransferFrame.PayloadHeader"; +} + + +// =================================================================== + +class PayloadTransferFrame_PayloadChunk::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_flags(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_offset(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_body(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +PayloadTransferFrame_PayloadChunk::PayloadTransferFrame_PayloadChunk(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.PayloadTransferFrame.PayloadChunk) +} +PayloadTransferFrame_PayloadChunk::PayloadTransferFrame_PayloadChunk(const PayloadTransferFrame_PayloadChunk& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_body()) { + body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_body(), + GetArenaForAllocation()); + } + ::memcpy(&offset_, &from.offset_, + static_cast(reinterpret_cast(&flags_) - + reinterpret_cast(&offset_)) + sizeof(flags_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.PayloadTransferFrame.PayloadChunk) +} + +inline void PayloadTransferFrame_PayloadChunk::SharedCtor() { +body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&offset_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&flags_) - + reinterpret_cast(&offset_)) + sizeof(flags_)); +} + +PayloadTransferFrame_PayloadChunk::~PayloadTransferFrame_PayloadChunk() { + // @@protoc_insertion_point(destructor:location.nearby.connections.PayloadTransferFrame.PayloadChunk) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void PayloadTransferFrame_PayloadChunk::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + body_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void PayloadTransferFrame_PayloadChunk::ArenaDtor(void* object) { + PayloadTransferFrame_PayloadChunk* _this = reinterpret_cast< PayloadTransferFrame_PayloadChunk* >(object); + (void)_this; +} +void PayloadTransferFrame_PayloadChunk::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PayloadTransferFrame_PayloadChunk::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PayloadTransferFrame_PayloadChunk::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.PayloadTransferFrame.PayloadChunk) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + body_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000006u) { + ::memset(&offset_, 0, static_cast( + reinterpret_cast(&flags_) - + reinterpret_cast(&offset_)) + sizeof(flags_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* PayloadTransferFrame_PayloadChunk::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 flags = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_flags(&has_bits); + flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 offset = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_offset(&has_bits); + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes body = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_body(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PayloadTransferFrame_PayloadChunk::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.PayloadTransferFrame.PayloadChunk) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 flags = 1; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_flags(), target); + } + + // optional int64 offset = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_offset(), target); + } + + // optional bytes body = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_body(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.PayloadTransferFrame.PayloadChunk) + return target; +} + +size_t PayloadTransferFrame_PayloadChunk::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.PayloadTransferFrame.PayloadChunk) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional bytes body = 3; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_body()); + } + + // optional int64 offset = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset()); + } + + // optional int32 flags = 1; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_flags()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PayloadTransferFrame_PayloadChunk::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void PayloadTransferFrame_PayloadChunk::MergeFrom(const PayloadTransferFrame_PayloadChunk& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.PayloadTransferFrame.PayloadChunk) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_body(from._internal_body()); + } + if (cached_has_bits & 0x00000002u) { + offset_ = from.offset_; + } + if (cached_has_bits & 0x00000004u) { + flags_ = from.flags_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void PayloadTransferFrame_PayloadChunk::CopyFrom(const PayloadTransferFrame_PayloadChunk& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.PayloadTransferFrame.PayloadChunk) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PayloadTransferFrame_PayloadChunk::IsInitialized() const { + return true; +} + +void PayloadTransferFrame_PayloadChunk::InternalSwap(PayloadTransferFrame_PayloadChunk* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &body_, lhs_arena, + &other->body_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PayloadTransferFrame_PayloadChunk, flags_) + + sizeof(PayloadTransferFrame_PayloadChunk::flags_) + - PROTOBUF_FIELD_OFFSET(PayloadTransferFrame_PayloadChunk, offset_)>( + reinterpret_cast(&offset_), + reinterpret_cast(&other->offset_)); +} + +std::string PayloadTransferFrame_PayloadChunk::GetTypeName() const { + return "location.nearby.connections.PayloadTransferFrame.PayloadChunk"; +} + + +// =================================================================== + +class PayloadTransferFrame_ControlMessage::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_event(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_offset(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +PayloadTransferFrame_ControlMessage::PayloadTransferFrame_ControlMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.PayloadTransferFrame.ControlMessage) +} +PayloadTransferFrame_ControlMessage::PayloadTransferFrame_ControlMessage(const PayloadTransferFrame_ControlMessage& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&offset_, &from.offset_, + static_cast(reinterpret_cast(&event_) - + reinterpret_cast(&offset_)) + sizeof(event_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.PayloadTransferFrame.ControlMessage) +} + +inline void PayloadTransferFrame_ControlMessage::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&offset_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&event_) - + reinterpret_cast(&offset_)) + sizeof(event_)); +} + +PayloadTransferFrame_ControlMessage::~PayloadTransferFrame_ControlMessage() { + // @@protoc_insertion_point(destructor:location.nearby.connections.PayloadTransferFrame.ControlMessage) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void PayloadTransferFrame_ControlMessage::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void PayloadTransferFrame_ControlMessage::ArenaDtor(void* object) { + PayloadTransferFrame_ControlMessage* _this = reinterpret_cast< PayloadTransferFrame_ControlMessage* >(object); + (void)_this; +} +void PayloadTransferFrame_ControlMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PayloadTransferFrame_ControlMessage::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PayloadTransferFrame_ControlMessage::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.PayloadTransferFrame.ControlMessage) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&offset_, 0, static_cast( + reinterpret_cast(&event_) - + reinterpret_cast(&offset_)) + sizeof(event_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* PayloadTransferFrame_ControlMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .location.nearby.connections.PayloadTransferFrame.ControlMessage.EventType event = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType_IsValid(val))) { + _internal_set_event(static_cast<::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int64 offset = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_offset(&has_bits); + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PayloadTransferFrame_ControlMessage::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.PayloadTransferFrame.ControlMessage) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.connections.PayloadTransferFrame.ControlMessage.EventType event = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_event(), target); + } + + // optional int64 offset = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_offset(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.PayloadTransferFrame.ControlMessage) + return target; +} + +size_t PayloadTransferFrame_ControlMessage::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.PayloadTransferFrame.ControlMessage) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional int64 offset = 2; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset()); + } + + // optional .location.nearby.connections.PayloadTransferFrame.ControlMessage.EventType event = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_event()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PayloadTransferFrame_ControlMessage::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void PayloadTransferFrame_ControlMessage::MergeFrom(const PayloadTransferFrame_ControlMessage& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.PayloadTransferFrame.ControlMessage) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + offset_ = from.offset_; + } + if (cached_has_bits & 0x00000002u) { + event_ = from.event_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void PayloadTransferFrame_ControlMessage::CopyFrom(const PayloadTransferFrame_ControlMessage& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.PayloadTransferFrame.ControlMessage) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PayloadTransferFrame_ControlMessage::IsInitialized() const { + return true; +} + +void PayloadTransferFrame_ControlMessage::InternalSwap(PayloadTransferFrame_ControlMessage* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PayloadTransferFrame_ControlMessage, event_) + + sizeof(PayloadTransferFrame_ControlMessage::event_) + - PROTOBUF_FIELD_OFFSET(PayloadTransferFrame_ControlMessage, offset_)>( + reinterpret_cast(&offset_), + reinterpret_cast(&other->offset_)); +} + +std::string PayloadTransferFrame_ControlMessage::GetTypeName() const { + return "location.nearby.connections.PayloadTransferFrame.ControlMessage"; +} + + +// =================================================================== + +class PayloadTransferFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_packet_type(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::location::nearby::connections::PayloadTransferFrame_PayloadHeader& payload_header(const PayloadTransferFrame* msg); + static void set_has_payload_header(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::location::nearby::connections::PayloadTransferFrame_PayloadChunk& payload_chunk(const PayloadTransferFrame* msg); + static void set_has_payload_chunk(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::location::nearby::connections::PayloadTransferFrame_ControlMessage& control_message(const PayloadTransferFrame* msg); + static void set_has_control_message(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::location::nearby::connections::PayloadTransferFrame_PayloadHeader& +PayloadTransferFrame::_Internal::payload_header(const PayloadTransferFrame* msg) { + return *msg->payload_header_; +} +const ::location::nearby::connections::PayloadTransferFrame_PayloadChunk& +PayloadTransferFrame::_Internal::payload_chunk(const PayloadTransferFrame* msg) { + return *msg->payload_chunk_; +} +const ::location::nearby::connections::PayloadTransferFrame_ControlMessage& +PayloadTransferFrame::_Internal::control_message(const PayloadTransferFrame* msg) { + return *msg->control_message_; +} +PayloadTransferFrame::PayloadTransferFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.PayloadTransferFrame) +} +PayloadTransferFrame::PayloadTransferFrame(const PayloadTransferFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_payload_header()) { + payload_header_ = new ::location::nearby::connections::PayloadTransferFrame_PayloadHeader(*from.payload_header_); + } else { + payload_header_ = nullptr; + } + if (from._internal_has_payload_chunk()) { + payload_chunk_ = new ::location::nearby::connections::PayloadTransferFrame_PayloadChunk(*from.payload_chunk_); + } else { + payload_chunk_ = nullptr; + } + if (from._internal_has_control_message()) { + control_message_ = new ::location::nearby::connections::PayloadTransferFrame_ControlMessage(*from.control_message_); + } else { + control_message_ = nullptr; + } + packet_type_ = from.packet_type_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.PayloadTransferFrame) +} + +inline void PayloadTransferFrame::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&payload_header_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&packet_type_) - + reinterpret_cast(&payload_header_)) + sizeof(packet_type_)); +} + +PayloadTransferFrame::~PayloadTransferFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.PayloadTransferFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void PayloadTransferFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete payload_header_; + if (this != internal_default_instance()) delete payload_chunk_; + if (this != internal_default_instance()) delete control_message_; +} + +void PayloadTransferFrame::ArenaDtor(void* object) { + PayloadTransferFrame* _this = reinterpret_cast< PayloadTransferFrame* >(object); + (void)_this; +} +void PayloadTransferFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PayloadTransferFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PayloadTransferFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.PayloadTransferFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(payload_header_ != nullptr); + payload_header_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(payload_chunk_ != nullptr); + payload_chunk_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(control_message_ != nullptr); + control_message_->Clear(); + } + } + packet_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* PayloadTransferFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .location.nearby.connections.PayloadTransferFrame.PacketType packet_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::PayloadTransferFrame_PacketType_IsValid(val))) { + _internal_set_packet_type(static_cast<::location::nearby::connections::PayloadTransferFrame_PacketType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader payload_header = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_payload_header(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.PayloadTransferFrame.PayloadChunk payload_chunk = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_payload_chunk(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.PayloadTransferFrame.ControlMessage control_message = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_control_message(), 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(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PayloadTransferFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.PayloadTransferFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.connections.PayloadTransferFrame.PacketType packet_type = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_packet_type(), target); + } + + // optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader payload_header = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::payload_header(this), target, stream); + } + + // optional .location.nearby.connections.PayloadTransferFrame.PayloadChunk payload_chunk = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::payload_chunk(this), target, stream); + } + + // optional .location.nearby.connections.PayloadTransferFrame.ControlMessage control_message = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::control_message(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.PayloadTransferFrame) + return target; +} + +size_t PayloadTransferFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.PayloadTransferFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader payload_header = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *payload_header_); + } + + // optional .location.nearby.connections.PayloadTransferFrame.PayloadChunk payload_chunk = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *payload_chunk_); + } + + // optional .location.nearby.connections.PayloadTransferFrame.ControlMessage control_message = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *control_message_); + } + + // optional .location.nearby.connections.PayloadTransferFrame.PacketType packet_type = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_packet_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PayloadTransferFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void PayloadTransferFrame::MergeFrom(const PayloadTransferFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.PayloadTransferFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_payload_header()->::location::nearby::connections::PayloadTransferFrame_PayloadHeader::MergeFrom(from._internal_payload_header()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_payload_chunk()->::location::nearby::connections::PayloadTransferFrame_PayloadChunk::MergeFrom(from._internal_payload_chunk()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_control_message()->::location::nearby::connections::PayloadTransferFrame_ControlMessage::MergeFrom(from._internal_control_message()); + } + if (cached_has_bits & 0x00000008u) { + packet_type_ = from.packet_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void PayloadTransferFrame::CopyFrom(const PayloadTransferFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.PayloadTransferFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PayloadTransferFrame::IsInitialized() const { + return true; +} + +void PayloadTransferFrame::InternalSwap(PayloadTransferFrame* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(PayloadTransferFrame, packet_type_) + + sizeof(PayloadTransferFrame::packet_type_) + - PROTOBUF_FIELD_OFFSET(PayloadTransferFrame, payload_header_)>( + reinterpret_cast(&payload_header_), + reinterpret_cast(&other->payload_header_)); +} + +std::string PayloadTransferFrame::GetTypeName() const { + return "location.nearby.connections.PayloadTransferFrame"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_ssid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_password(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_port(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_gateway(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_frequency(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } +}; + +const ::PROTOBUF_NAMESPACE_ID::internal::LazyString BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_i_give_permission_to_break_this_code_default_gateway_{{{"0.0.0.0", 7}}, {nullptr}}; +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) +} +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ssid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ssid()) { + ssid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_ssid(), + GetArenaForAllocation()); + } + password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_password()) { + password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_password(), + GetArenaForAllocation()); + } + gateway_.UnsafeSetDefault(nullptr); + if (from._internal_has_gateway()) { + gateway_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_gateway(), + GetArenaForAllocation()); + } + ::memcpy(&port_, &from.port_, + static_cast(reinterpret_cast(&frequency_) - + reinterpret_cast(&port_)) + sizeof(frequency_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::SharedCtor() { +ssid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +gateway_.UnsafeSetDefault(nullptr); +port_ = 0; +frequency_ = -1; +} + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + ssid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + password_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + gateway_.DestroyNoArena(nullptr); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + ssid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + password_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + gateway_.ClearToDefault(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_i_give_permission_to_break_this_code_default_gateway_, GetArenaForAllocation()); + } + } + if (cached_has_bits & 0x00000018u) { + port_ = 0; + frequency_ = -1; + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string ssid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_ssid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string password = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_password(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 port = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_port(&has_bits); + port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string gateway = 4 [default = "0.0.0.0"]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_gateway(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 frequency = 5 [default = -1]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_frequency(&has_bits); + frequency_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string ssid = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_ssid(), target); + } + + // optional string password = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 2, this->_internal_password(), target); + } + + // optional int32 port = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_port(), target); + } + + // optional string gateway = 4 [default = "0.0.0.0"]; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteStringMaybeAliased( + 4, this->_internal_gateway(), target); + } + + // optional int32 frequency = 5 [default = -1]; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_frequency(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional string ssid = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_ssid()); + } + + // optional string password = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_password()); + } + + // optional string gateway = 4 [default = "0.0.0.0"]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_gateway()); + } + + // optional int32 port = 3; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_port()); + } + + // optional int32 frequency = 5 [default = -1]; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_frequency()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_ssid(from._internal_ssid()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_password(from._internal_password()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_gateway(from._internal_gateway()); + } + if (cached_has_bits & 0x00000008u) { + port_ = from.port_; + } + if (cached_has_bits & 0x00000010u) { + frequency_ = from.frequency_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &ssid_, lhs_arena, + &other->ssid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &password_, lhs_arena, + &other->password_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + nullptr, + &gateway_, lhs_arena, + &other->gateway_, rhs_arena + ); + swap(port_, other->port_); + swap(frequency_, other->frequency_); +} + +std::string BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_ip_address(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_wifi_port(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) +} +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ip_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ip_address()) { + ip_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_ip_address(), + GetArenaForAllocation()); + } + wifi_port_ = from.wifi_port_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::SharedCtor() { +ip_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +wifi_port_ = 0; +} + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + ip_address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + ip_address_.ClearNonDefaultToEmpty(); + } + wifi_port_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes ip_address = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_ip_address(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 wifi_port = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_wifi_port(&has_bits); + wifi_port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bytes ip_address = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_ip_address(), target); + } + + // optional int32 wifi_port = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_wifi_port(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional bytes ip_address = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_ip_address()); + } + + // optional int32 wifi_port = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_wifi_port()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_ip_address(from._internal_ip_address()); + } + if (cached_has_bits & 0x00000002u) { + wifi_port_ = from.wifi_port_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &ip_address_, lhs_arena, + &other->ip_address_, rhs_arena + ); + swap(wifi_port_, other->wifi_port_); +} + +std::string BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_service_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_mac_address(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) +} +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + service_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + service_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_service_name()) { + service_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_service_name(), + GetArenaForAllocation()); + } + mac_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mac_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_mac_address()) { + mac_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_mac_address(), + GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::SharedCtor() { +service_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + service_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +mac_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + mac_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + service_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + mac_address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + service_name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + mac_address_.ClearNonDefaultToEmpty(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string service_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_service_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string mac_address = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_mac_address(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string service_name = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_service_name(), target); + } + + // optional string mac_address = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 2, this->_internal_mac_address(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string service_name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_service_name()); + } + + // optional string mac_address = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_mac_address()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_service_name(from._internal_service_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_mac_address(from._internal_mac_address()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &service_name_, lhs_arena, + &other->service_name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &mac_address_, lhs_arena, + &other->mac_address_, rhs_arena + ); +} + +std::string BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_service_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_service_info(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_password(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) +} +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + service_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + service_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_service_id()) { + service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_service_id(), + GetArenaForAllocation()); + } + service_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + service_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_service_info()) { + service_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_service_info(), + GetArenaForAllocation()); + } + password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_password()) { + password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_password(), + GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::SharedCtor() { +service_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + service_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +service_info_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + service_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + service_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + service_info_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + password_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + service_id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + service_info_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + password_.ClearNonDefaultToEmpty(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string service_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_service_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes service_info = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_service_info(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string password = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_password(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string service_id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_service_id(), target); + } + + // optional bytes service_info = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_service_info(), target); + } + + // optional string password = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteStringMaybeAliased( + 3, this->_internal_password(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string service_id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_service_id()); + } + + // optional bytes service_info = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_service_info()); + } + + // optional string password = 3; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_password()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_service_id(from._internal_service_id()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_service_info(from._internal_service_info()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_password(from._internal_password()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &service_id_, lhs_arena, + &other->service_id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &service_info_, lhs_arena, + &other->service_info_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &password_, lhs_arena, + &other->password_, rhs_arena + ); +} + +std::string BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_ssid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_password(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_port(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_frequency(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_gateway(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::PROTOBUF_NAMESPACE_ID::internal::LazyString BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_i_give_permission_to_break_this_code_default_gateway_{{{"0.0.0.0", 7}}, {nullptr}}; +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) +} +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ssid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ssid()) { + ssid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_ssid(), + GetArenaForAllocation()); + } + password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_password()) { + password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_password(), + GetArenaForAllocation()); + } + gateway_.UnsafeSetDefault(nullptr); + if (from._internal_has_gateway()) { + gateway_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_gateway(), + GetArenaForAllocation()); + } + ::memcpy(&port_, &from.port_, + static_cast(reinterpret_cast(&frequency_) - + reinterpret_cast(&port_)) + sizeof(frequency_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::SharedCtor() { +ssid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +gateway_.UnsafeSetDefault(nullptr); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&port_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&frequency_) - + reinterpret_cast(&port_)) + sizeof(frequency_)); +} + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + ssid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + password_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + gateway_.DestroyNoArena(nullptr); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + ssid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + password_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + gateway_.ClearToDefault(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_i_give_permission_to_break_this_code_default_gateway_, GetArenaForAllocation()); + } + } + if (cached_has_bits & 0x00000018u) { + ::memset(&port_, 0, static_cast( + reinterpret_cast(&frequency_) - + reinterpret_cast(&port_)) + sizeof(frequency_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string ssid = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_ssid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string password = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_password(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 port = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_port(&has_bits); + port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 frequency = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_frequency(&has_bits); + frequency_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string gateway = 5 [default = "0.0.0.0"]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + auto str = _internal_mutable_gateway(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string ssid = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_ssid(), target); + } + + // optional string password = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 2, this->_internal_password(), target); + } + + // optional int32 port = 3; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_port(), target); + } + + // optional int32 frequency = 4; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_frequency(), target); + } + + // optional string gateway = 5 [default = "0.0.0.0"]; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteStringMaybeAliased( + 5, this->_internal_gateway(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional string ssid = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_ssid()); + } + + // optional string password = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_password()); + } + + // optional string gateway = 5 [default = "0.0.0.0"]; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_gateway()); + } + + // optional int32 port = 3; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_port()); + } + + // optional int32 frequency = 4; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_frequency()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_ssid(from._internal_ssid()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_password(from._internal_password()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_gateway(from._internal_gateway()); + } + if (cached_has_bits & 0x00000008u) { + port_ = from.port_; + } + if (cached_has_bits & 0x00000010u) { + frequency_ = from.frequency_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &ssid_, lhs_arena, + &other->ssid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &password_, lhs_arena, + &other->password_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + nullptr, + &gateway_, lhs_arena, + &other->gateway_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials, frequency_) + + sizeof(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::frequency_) + - PROTOBUF_FIELD_OFFSET(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials, port_)>( + reinterpret_cast(&port_), + reinterpret_cast(&other->port_)); +} + +std::string BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_peer_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::location::nearby::connections::LocationHint& location_hint(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* msg); + static void set_has_location_hint(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::location::nearby::connections::LocationHint& +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_Internal::location_hint(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* msg) { + return *msg->location_hint_; +} +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) +} +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + peer_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + peer_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_peer_id()) { + peer_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_peer_id(), + GetArenaForAllocation()); + } + if (from._internal_has_location_hint()) { + location_hint_ = new ::location::nearby::connections::LocationHint(*from.location_hint_); + } else { + location_hint_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::SharedCtor() { +peer_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + peer_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +location_hint_ = nullptr; +} + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + peer_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete location_hint_; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + peer_id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(location_hint_ != nullptr); + location_hint_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string peer_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_peer_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.LocationHint location_hint = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_location_hint(), 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(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string peer_id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_peer_id(), target); + } + + // optional .location.nearby.connections.LocationHint location_hint = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::location_hint(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string peer_id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_peer_id()); + } + + // optional .location.nearby.connections.LocationHint location_hint = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *location_hint_); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_peer_id(from._internal_peer_id()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_location_hint()->::location::nearby::connections::LocationHint::MergeFrom(from._internal_location_hint()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &peer_id_, lhs_arena, + &other->peer_id_, rhs_arena + ); + swap(location_hint_, other->location_hint_); +} + +std::string BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_medium(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& wifi_hotspot_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg); + static void set_has_wifi_hotspot_credentials(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& wifi_lan_socket(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg); + static void set_has_wifi_lan_socket(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& bluetooth_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg); + static void set_has_bluetooth_credentials(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& wifi_aware_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg); + static void set_has_wifi_aware_credentials(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& wifi_direct_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg); + static void set_has_wifi_direct_credentials(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& web_rtc_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg); + static void set_has_web_rtc_credentials(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_supports_disabling_encryption(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_supports_client_introduction_ack(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } +}; + +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& +BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_Internal::wifi_hotspot_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg) { + return *msg->wifi_hotspot_credentials_; +} +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& +BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_Internal::wifi_lan_socket(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg) { + return *msg->wifi_lan_socket_; +} +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& +BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_Internal::bluetooth_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg) { + return *msg->bluetooth_credentials_; +} +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& +BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_Internal::wifi_aware_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg) { + return *msg->wifi_aware_credentials_; +} +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& +BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_Internal::wifi_direct_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg) { + return *msg->wifi_direct_credentials_; +} +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& +BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_Internal::web_rtc_credentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* msg) { + return *msg->web_rtc_credentials_; +} +BandwidthUpgradeNegotiationFrame_UpgradePathInfo::BandwidthUpgradeNegotiationFrame_UpgradePathInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) +} +BandwidthUpgradeNegotiationFrame_UpgradePathInfo::BandwidthUpgradeNegotiationFrame_UpgradePathInfo(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_wifi_hotspot_credentials()) { + wifi_hotspot_credentials_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials(*from.wifi_hotspot_credentials_); + } else { + wifi_hotspot_credentials_ = nullptr; + } + if (from._internal_has_wifi_lan_socket()) { + wifi_lan_socket_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket(*from.wifi_lan_socket_); + } else { + wifi_lan_socket_ = nullptr; + } + if (from._internal_has_bluetooth_credentials()) { + bluetooth_credentials_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials(*from.bluetooth_credentials_); + } else { + bluetooth_credentials_ = nullptr; + } + if (from._internal_has_wifi_aware_credentials()) { + wifi_aware_credentials_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials(*from.wifi_aware_credentials_); + } else { + wifi_aware_credentials_ = nullptr; + } + if (from._internal_has_wifi_direct_credentials()) { + wifi_direct_credentials_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials(*from.wifi_direct_credentials_); + } else { + wifi_direct_credentials_ = nullptr; + } + if (from._internal_has_web_rtc_credentials()) { + web_rtc_credentials_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials(*from.web_rtc_credentials_); + } else { + web_rtc_credentials_ = nullptr; + } + ::memcpy(&medium_, &from.medium_, + static_cast(reinterpret_cast(&supports_client_introduction_ack_) - + reinterpret_cast(&medium_)) + sizeof(supports_client_introduction_ack_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&wifi_hotspot_credentials_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&supports_client_introduction_ack_) - + reinterpret_cast(&wifi_hotspot_credentials_)) + sizeof(supports_client_introduction_ack_)); +} + +BandwidthUpgradeNegotiationFrame_UpgradePathInfo::~BandwidthUpgradeNegotiationFrame_UpgradePathInfo() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete wifi_hotspot_credentials_; + if (this != internal_default_instance()) delete wifi_lan_socket_; + if (this != internal_default_instance()) delete bluetooth_credentials_; + if (this != internal_default_instance()) delete wifi_aware_credentials_; + if (this != internal_default_instance()) delete wifi_direct_credentials_; + if (this != internal_default_instance()) delete web_rtc_credentials_; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame_UpgradePathInfo* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(wifi_hotspot_credentials_ != nullptr); + wifi_hotspot_credentials_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(wifi_lan_socket_ != nullptr); + wifi_lan_socket_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(bluetooth_credentials_ != nullptr); + bluetooth_credentials_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(wifi_aware_credentials_ != nullptr); + wifi_aware_credentials_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(wifi_direct_credentials_ != nullptr); + wifi_direct_credentials_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(web_rtc_credentials_ != nullptr); + web_rtc_credentials_->Clear(); + } + } + if (cached_has_bits & 0x000000c0u) { + ::memset(&medium_, 0, static_cast( + reinterpret_cast(&supports_disabling_encryption_) - + reinterpret_cast(&medium_)) + sizeof(supports_disabling_encryption_)); + } + supports_client_introduction_ack_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.Medium medium = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_IsValid(val))) { + _internal_set_medium(static_cast<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials wifi_hotspot_credentials = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_wifi_hotspot_credentials(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket wifi_lan_socket = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_wifi_lan_socket(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials bluetooth_credentials = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_bluetooth_credentials(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials wifi_aware_credentials = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_wifi_aware_credentials(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials wifi_direct_credentials = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_wifi_direct_credentials(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supports_disabling_encryption = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_supports_disabling_encryption(&has_bits); + supports_disabling_encryption_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials web_rtc_credentials = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_web_rtc_credentials(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supports_client_introduction_ack = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_supports_client_introduction_ack(&has_bits); + supports_client_introduction_ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.Medium medium = 1; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_medium(), target); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials wifi_hotspot_credentials = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::wifi_hotspot_credentials(this), target, stream); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket wifi_lan_socket = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::wifi_lan_socket(this), target, stream); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials bluetooth_credentials = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::bluetooth_credentials(this), target, stream); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials wifi_aware_credentials = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::wifi_aware_credentials(this), target, stream); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials wifi_direct_credentials = 6; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::wifi_direct_credentials(this), target, stream); + } + + // optional bool supports_disabling_encryption = 7; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_supports_disabling_encryption(), target); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials web_rtc_credentials = 8; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::web_rtc_credentials(this), target, stream); + } + + // optional bool supports_client_introduction_ack = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(9, this->_internal_supports_client_introduction_ack(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials wifi_hotspot_credentials = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *wifi_hotspot_credentials_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket wifi_lan_socket = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *wifi_lan_socket_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials bluetooth_credentials = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *bluetooth_credentials_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials wifi_aware_credentials = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *wifi_aware_credentials_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials wifi_direct_credentials = 6; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *wifi_direct_credentials_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials web_rtc_credentials = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *web_rtc_credentials_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.Medium medium = 1; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_medium()); + } + + // optional bool supports_disabling_encryption = 7; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 1; + } + + } + // optional bool supports_client_introduction_ack = 9; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 1; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_wifi_hotspot_credentials()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::MergeFrom(from._internal_wifi_hotspot_credentials()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_wifi_lan_socket()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::MergeFrom(from._internal_wifi_lan_socket()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_bluetooth_credentials()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::MergeFrom(from._internal_bluetooth_credentials()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_wifi_aware_credentials()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::MergeFrom(from._internal_wifi_aware_credentials()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_wifi_direct_credentials()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::MergeFrom(from._internal_wifi_direct_credentials()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_web_rtc_credentials()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::MergeFrom(from._internal_web_rtc_credentials()); + } + if (cached_has_bits & 0x00000040u) { + medium_ = from.medium_; + } + if (cached_has_bits & 0x00000080u) { + supports_disabling_encryption_ = from.supports_disabling_encryption_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000100u) { + _internal_set_supports_client_introduction_ack(from._internal_supports_client_introduction_ack()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(BandwidthUpgradeNegotiationFrame_UpgradePathInfo, supports_client_introduction_ack_) + + sizeof(BandwidthUpgradeNegotiationFrame_UpgradePathInfo::supports_client_introduction_ack_) + - PROTOBUF_FIELD_OFFSET(BandwidthUpgradeNegotiationFrame_UpgradePathInfo, wifi_hotspot_credentials_)>( + reinterpret_cast(&wifi_hotspot_credentials_), + reinterpret_cast(&other->wifi_hotspot_credentials_)); +} + +std::string BandwidthUpgradeNegotiationFrame_UpgradePathInfo::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame_ClientIntroduction::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_endpoint_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_supports_disabling_encryption(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +BandwidthUpgradeNegotiationFrame_ClientIntroduction::BandwidthUpgradeNegotiationFrame_ClientIntroduction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) +} +BandwidthUpgradeNegotiationFrame_ClientIntroduction::BandwidthUpgradeNegotiationFrame_ClientIntroduction(const BandwidthUpgradeNegotiationFrame_ClientIntroduction& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + endpoint_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_endpoint_id()) { + endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_endpoint_id(), + GetArenaForAllocation()); + } + supports_disabling_encryption_ = from.supports_disabling_encryption_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) +} + +inline void BandwidthUpgradeNegotiationFrame_ClientIntroduction::SharedCtor() { +endpoint_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +supports_disabling_encryption_ = false; +} + +BandwidthUpgradeNegotiationFrame_ClientIntroduction::~BandwidthUpgradeNegotiationFrame_ClientIntroduction() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame_ClientIntroduction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + endpoint_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroduction::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame_ClientIntroduction* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame_ClientIntroduction* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame_ClientIntroduction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame_ClientIntroduction::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroduction::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + endpoint_id_.ClearNonDefaultToEmpty(); + } + supports_disabling_encryption_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame_ClientIntroduction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string endpoint_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_endpoint_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supports_disabling_encryption = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_supports_disabling_encryption(&has_bits); + supports_disabling_encryption_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame_ClientIntroduction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string endpoint_id = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_endpoint_id(), target); + } + + // optional bool supports_disabling_encryption = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_supports_disabling_encryption(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame_ClientIntroduction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string endpoint_id = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_endpoint_id()); + } + + // optional bool supports_disabling_encryption = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + 1; + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroduction::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroduction::MergeFrom(const BandwidthUpgradeNegotiationFrame_ClientIntroduction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_endpoint_id(from._internal_endpoint_id()); + } + if (cached_has_bits & 0x00000002u) { + supports_disabling_encryption_ = from.supports_disabling_encryption_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroduction::CopyFrom(const BandwidthUpgradeNegotiationFrame_ClientIntroduction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame_ClientIntroduction::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroduction::InternalSwap(BandwidthUpgradeNegotiationFrame_ClientIntroduction* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &endpoint_id_, lhs_arena, + &other->endpoint_id_, rhs_arena + ); + swap(supports_disabling_encryption_, other->supports_disabling_encryption_); +} + +std::string BandwidthUpgradeNegotiationFrame_ClientIntroduction::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::_Internal { + public: +}; + +BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) +} +BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck(const BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) +} + +inline void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::SharedCtor() { +} + +BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::~BandwidthUpgradeNegotiationFrame_ClientIntroductionAck() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::MergeFrom(const BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::CopyFrom(const BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::InternalSwap(BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +std::string BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck"; +} + + +// =================================================================== + +class BandwidthUpgradeNegotiationFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_event_type(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo& upgrade_path_info(const BandwidthUpgradeNegotiationFrame* msg); + static void set_has_upgrade_path_info(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction& client_introduction(const BandwidthUpgradeNegotiationFrame* msg); + static void set_has_client_introduction(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& client_introduction_ack(const BandwidthUpgradeNegotiationFrame* msg); + static void set_has_client_introduction_ack(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo& +BandwidthUpgradeNegotiationFrame::_Internal::upgrade_path_info(const BandwidthUpgradeNegotiationFrame* msg) { + return *msg->upgrade_path_info_; +} +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction& +BandwidthUpgradeNegotiationFrame::_Internal::client_introduction(const BandwidthUpgradeNegotiationFrame* msg) { + return *msg->client_introduction_; +} +const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& +BandwidthUpgradeNegotiationFrame::_Internal::client_introduction_ack(const BandwidthUpgradeNegotiationFrame* msg) { + return *msg->client_introduction_ack_; +} +BandwidthUpgradeNegotiationFrame::BandwidthUpgradeNegotiationFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame) +} +BandwidthUpgradeNegotiationFrame::BandwidthUpgradeNegotiationFrame(const BandwidthUpgradeNegotiationFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_upgrade_path_info()) { + upgrade_path_info_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo(*from.upgrade_path_info_); + } else { + upgrade_path_info_ = nullptr; + } + if (from._internal_has_client_introduction()) { + client_introduction_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction(*from.client_introduction_); + } else { + client_introduction_ = nullptr; + } + if (from._internal_has_client_introduction_ack()) { + client_introduction_ack_ = new ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck(*from.client_introduction_ack_); + } else { + client_introduction_ack_ = nullptr; + } + event_type_ = from.event_type_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame) +} + +inline void BandwidthUpgradeNegotiationFrame::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&upgrade_path_info_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&event_type_) - + reinterpret_cast(&upgrade_path_info_)) + sizeof(event_type_)); +} + +BandwidthUpgradeNegotiationFrame::~BandwidthUpgradeNegotiationFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeNegotiationFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void BandwidthUpgradeNegotiationFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete upgrade_path_info_; + if (this != internal_default_instance()) delete client_introduction_; + if (this != internal_default_instance()) delete client_introduction_ack_; +} + +void BandwidthUpgradeNegotiationFrame::ArenaDtor(void* object) { + BandwidthUpgradeNegotiationFrame* _this = reinterpret_cast< BandwidthUpgradeNegotiationFrame* >(object); + (void)_this; +} +void BandwidthUpgradeNegotiationFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void BandwidthUpgradeNegotiationFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void BandwidthUpgradeNegotiationFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(upgrade_path_info_ != nullptr); + upgrade_path_info_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(client_introduction_ != nullptr); + client_introduction_->Clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(client_introduction_ack_ != nullptr); + client_introduction_ack_->Clear(); + } + } + event_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* BandwidthUpgradeNegotiationFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.EventType event_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType_IsValid(val))) { + _internal_set_event_type(static_cast<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo upgrade_path_info = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_upgrade_path_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction client_introduction = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_client_introduction(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck client_introduction_ack = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_client_introduction_ack(), 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(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* BandwidthUpgradeNegotiationFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.EventType event_type = 1; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_event_type(), target); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo upgrade_path_info = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::upgrade_path_info(this), target, stream); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction client_introduction = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::client_introduction(this), target, stream); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck client_introduction_ack = 4; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::client_introduction_ack(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeNegotiationFrame) + return target; +} + +size_t BandwidthUpgradeNegotiationFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo upgrade_path_info = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *upgrade_path_info_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction client_introduction = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *client_introduction_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck client_introduction_ack = 4; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *client_introduction_ack_); + } + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.EventType event_type = 1; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_event_type()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void BandwidthUpgradeNegotiationFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void BandwidthUpgradeNegotiationFrame::MergeFrom(const BandwidthUpgradeNegotiationFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_upgrade_path_info()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo::MergeFrom(from._internal_upgrade_path_info()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_client_introduction()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction::MergeFrom(from._internal_client_introduction()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_client_introduction_ack()->::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck::MergeFrom(from._internal_client_introduction_ack()); + } + if (cached_has_bits & 0x00000008u) { + event_type_ = from.event_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BandwidthUpgradeNegotiationFrame::CopyFrom(const BandwidthUpgradeNegotiationFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeNegotiationFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool BandwidthUpgradeNegotiationFrame::IsInitialized() const { + return true; +} + +void BandwidthUpgradeNegotiationFrame::InternalSwap(BandwidthUpgradeNegotiationFrame* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(BandwidthUpgradeNegotiationFrame, event_type_) + + sizeof(BandwidthUpgradeNegotiationFrame::event_type_) + - PROTOBUF_FIELD_OFFSET(BandwidthUpgradeNegotiationFrame, upgrade_path_info_)>( + reinterpret_cast(&upgrade_path_info_), + reinterpret_cast(&other->upgrade_path_info_)); +} + +std::string BandwidthUpgradeNegotiationFrame::GetTypeName() const { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame"; +} + + +// =================================================================== + +class KeepAliveFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_ack(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +KeepAliveFrame::KeepAliveFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.KeepAliveFrame) +} +KeepAliveFrame::KeepAliveFrame(const KeepAliveFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ack_ = from.ack_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.KeepAliveFrame) +} + +inline void KeepAliveFrame::SharedCtor() { +ack_ = false; +} + +KeepAliveFrame::~KeepAliveFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.KeepAliveFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void KeepAliveFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void KeepAliveFrame::ArenaDtor(void* object) { + KeepAliveFrame* _this = reinterpret_cast< KeepAliveFrame* >(object); + (void)_this; +} +void KeepAliveFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void KeepAliveFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void KeepAliveFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.KeepAliveFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ack_ = false; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* KeepAliveFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool ack = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_ack(&has_bits); + ack_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* KeepAliveFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.KeepAliveFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bool ack = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_ack(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.KeepAliveFrame) + return target; +} + +size_t KeepAliveFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.KeepAliveFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bool ack = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + 1; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void KeepAliveFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void KeepAliveFrame::MergeFrom(const KeepAliveFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.KeepAliveFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_ack()) { + _internal_set_ack(from._internal_ack()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void KeepAliveFrame::CopyFrom(const KeepAliveFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.KeepAliveFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool KeepAliveFrame::IsInitialized() const { + return true; +} + +void KeepAliveFrame::InternalSwap(KeepAliveFrame* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(ack_, other->ack_); +} + +std::string KeepAliveFrame::GetTypeName() const { + return "location.nearby.connections.KeepAliveFrame"; +} + + +// =================================================================== + +class DisconnectionFrame::_Internal { + public: +}; + +DisconnectionFrame::DisconnectionFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.DisconnectionFrame) +} +DisconnectionFrame::DisconnectionFrame(const DisconnectionFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.DisconnectionFrame) +} + +inline void DisconnectionFrame::SharedCtor() { +} + +DisconnectionFrame::~DisconnectionFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.DisconnectionFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void DisconnectionFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void DisconnectionFrame::ArenaDtor(void* object) { + DisconnectionFrame* _this = reinterpret_cast< DisconnectionFrame* >(object); + (void)_this; +} +void DisconnectionFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DisconnectionFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DisconnectionFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.DisconnectionFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +const char* DisconnectionFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* DisconnectionFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.DisconnectionFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.DisconnectionFrame) + return target; +} + +size_t DisconnectionFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.DisconnectionFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DisconnectionFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void DisconnectionFrame::MergeFrom(const DisconnectionFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.DisconnectionFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void DisconnectionFrame::CopyFrom(const DisconnectionFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.DisconnectionFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DisconnectionFrame::IsInitialized() const { + return true; +} + +void DisconnectionFrame::InternalSwap(DisconnectionFrame* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +std::string DisconnectionFrame::GetTypeName() const { + return "location.nearby.connections.DisconnectionFrame"; +} + + +// =================================================================== + +class PairedKeyEncryptionFrame::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_signed_data(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +PairedKeyEncryptionFrame::PairedKeyEncryptionFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.PairedKeyEncryptionFrame) +} +PairedKeyEncryptionFrame::PairedKeyEncryptionFrame(const PairedKeyEncryptionFrame& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + signed_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + signed_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_signed_data()) { + signed_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_signed_data(), + GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.PairedKeyEncryptionFrame) +} + +inline void PairedKeyEncryptionFrame::SharedCtor() { +signed_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + signed_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +PairedKeyEncryptionFrame::~PairedKeyEncryptionFrame() { + // @@protoc_insertion_point(destructor:location.nearby.connections.PairedKeyEncryptionFrame) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void PairedKeyEncryptionFrame::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + signed_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void PairedKeyEncryptionFrame::ArenaDtor(void* object) { + PairedKeyEncryptionFrame* _this = reinterpret_cast< PairedKeyEncryptionFrame* >(object); + (void)_this; +} +void PairedKeyEncryptionFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PairedKeyEncryptionFrame::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PairedKeyEncryptionFrame::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.PairedKeyEncryptionFrame) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + signed_data_.ClearNonDefaultToEmpty(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* PairedKeyEncryptionFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bytes signed_data = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_signed_data(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* PairedKeyEncryptionFrame::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.PairedKeyEncryptionFrame) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bytes signed_data = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_signed_data(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.PairedKeyEncryptionFrame) + return target; +} + +size_t PairedKeyEncryptionFrame::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.PairedKeyEncryptionFrame) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional bytes signed_data = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_signed_data()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PairedKeyEncryptionFrame::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void PairedKeyEncryptionFrame::MergeFrom(const PairedKeyEncryptionFrame& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.PairedKeyEncryptionFrame) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_signed_data()) { + _internal_set_signed_data(from._internal_signed_data()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void PairedKeyEncryptionFrame::CopyFrom(const PairedKeyEncryptionFrame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.PairedKeyEncryptionFrame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PairedKeyEncryptionFrame::IsInitialized() const { + return true; +} + +void PairedKeyEncryptionFrame::InternalSwap(PairedKeyEncryptionFrame* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &signed_data_, lhs_arena, + &other->signed_data_, rhs_arena + ); +} + +std::string PairedKeyEncryptionFrame::GetTypeName() const { + return "location.nearby.connections.PairedKeyEncryptionFrame"; +} + + +// =================================================================== + +class MediumMetadata::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_supports_5_ghz(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_bssid(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_ip_address(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_supports_6_ghz(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_mobile_radio(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_ap_frequency(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static const ::location::nearby::connections::AvailableChannels& available_channels(const MediumMetadata* msg); + static void set_has_available_channels(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static const ::location::nearby::connections::WifiDirectCliUsableChannels& wifi_direct_cli_usable_channels(const MediumMetadata* msg); + static void set_has_wifi_direct_cli_usable_channels(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static const ::location::nearby::connections::WifiLanUsableChannels& wifi_lan_usable_channels(const MediumMetadata* msg); + static void set_has_wifi_lan_usable_channels(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static const ::location::nearby::connections::WifiAwareUsableChannels& wifi_aware_usable_channels(const MediumMetadata* msg); + static void set_has_wifi_aware_usable_channels(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::location::nearby::connections::WifiHotspotStaUsableChannels& wifi_hotspot_sta_usable_channels(const MediumMetadata* msg); + static void set_has_wifi_hotspot_sta_usable_channels(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } +}; + +const ::location::nearby::connections::AvailableChannels& +MediumMetadata::_Internal::available_channels(const MediumMetadata* msg) { + return *msg->available_channels_; +} +const ::location::nearby::connections::WifiDirectCliUsableChannels& +MediumMetadata::_Internal::wifi_direct_cli_usable_channels(const MediumMetadata* msg) { + return *msg->wifi_direct_cli_usable_channels_; +} +const ::location::nearby::connections::WifiLanUsableChannels& +MediumMetadata::_Internal::wifi_lan_usable_channels(const MediumMetadata* msg) { + return *msg->wifi_lan_usable_channels_; +} +const ::location::nearby::connections::WifiAwareUsableChannels& +MediumMetadata::_Internal::wifi_aware_usable_channels(const MediumMetadata* msg) { + return *msg->wifi_aware_usable_channels_; +} +const ::location::nearby::connections::WifiHotspotStaUsableChannels& +MediumMetadata::_Internal::wifi_hotspot_sta_usable_channels(const MediumMetadata* msg) { + return *msg->wifi_hotspot_sta_usable_channels_; +} +MediumMetadata::MediumMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.MediumMetadata) +} +MediumMetadata::MediumMetadata(const MediumMetadata& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + bssid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + bssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_bssid()) { + bssid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_bssid(), + GetArenaForAllocation()); + } + ip_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ip_address()) { + ip_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_ip_address(), + GetArenaForAllocation()); + } + if (from._internal_has_available_channels()) { + available_channels_ = new ::location::nearby::connections::AvailableChannels(*from.available_channels_); + } else { + available_channels_ = nullptr; + } + if (from._internal_has_wifi_direct_cli_usable_channels()) { + wifi_direct_cli_usable_channels_ = new ::location::nearby::connections::WifiDirectCliUsableChannels(*from.wifi_direct_cli_usable_channels_); + } else { + wifi_direct_cli_usable_channels_ = nullptr; + } + if (from._internal_has_wifi_lan_usable_channels()) { + wifi_lan_usable_channels_ = new ::location::nearby::connections::WifiLanUsableChannels(*from.wifi_lan_usable_channels_); + } else { + wifi_lan_usable_channels_ = nullptr; + } + if (from._internal_has_wifi_aware_usable_channels()) { + wifi_aware_usable_channels_ = new ::location::nearby::connections::WifiAwareUsableChannels(*from.wifi_aware_usable_channels_); + } else { + wifi_aware_usable_channels_ = nullptr; + } + if (from._internal_has_wifi_hotspot_sta_usable_channels()) { + wifi_hotspot_sta_usable_channels_ = new ::location::nearby::connections::WifiHotspotStaUsableChannels(*from.wifi_hotspot_sta_usable_channels_); + } else { + wifi_hotspot_sta_usable_channels_ = nullptr; + } + ::memcpy(&supports_5_ghz_, &from.supports_5_ghz_, + static_cast(reinterpret_cast(&ap_frequency_) - + reinterpret_cast(&supports_5_ghz_)) + sizeof(ap_frequency_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.MediumMetadata) +} + +inline void MediumMetadata::SharedCtor() { +bssid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + bssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +ip_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&available_channels_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&mobile_radio_) - + reinterpret_cast(&available_channels_)) + sizeof(mobile_radio_)); +ap_frequency_ = -1; +} + +MediumMetadata::~MediumMetadata() { + // @@protoc_insertion_point(destructor:location.nearby.connections.MediumMetadata) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void MediumMetadata::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + bssid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + ip_address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete available_channels_; + if (this != internal_default_instance()) delete wifi_direct_cli_usable_channels_; + if (this != internal_default_instance()) delete wifi_lan_usable_channels_; + if (this != internal_default_instance()) delete wifi_aware_usable_channels_; + if (this != internal_default_instance()) delete wifi_hotspot_sta_usable_channels_; +} + +void MediumMetadata::ArenaDtor(void* object) { + MediumMetadata* _this = reinterpret_cast< MediumMetadata* >(object); + (void)_this; +} +void MediumMetadata::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MediumMetadata::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MediumMetadata::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.MediumMetadata) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + bssid_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + ip_address_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(available_channels_ != nullptr); + available_channels_->Clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(wifi_direct_cli_usable_channels_ != nullptr); + wifi_direct_cli_usable_channels_->Clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(wifi_lan_usable_channels_ != nullptr); + wifi_lan_usable_channels_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(wifi_aware_usable_channels_ != nullptr); + wifi_aware_usable_channels_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(wifi_hotspot_sta_usable_channels_ != nullptr); + wifi_hotspot_sta_usable_channels_->Clear(); + } + } + supports_5_ghz_ = false; + ::memset(&supports_6_ghz_, 0, static_cast( + reinterpret_cast(&mobile_radio_) - + reinterpret_cast(&supports_6_ghz_)) + sizeof(mobile_radio_)); + ap_frequency_ = -1; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* MediumMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional bool supports_5_ghz = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_supports_5_ghz(&has_bits); + supports_5_ghz_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string bssid = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_bssid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes ip_address = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_ip_address(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool supports_6_ghz = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_supports_6_ghz(&has_bits); + supports_6_ghz_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool mobile_radio = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_mobile_radio(&has_bits); + mobile_radio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 ap_frequency = 6 [default = -1]; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_ap_frequency(&has_bits); + ap_frequency_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.AvailableChannels available_channels = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_available_channels(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.WifiDirectCliUsableChannels wifi_direct_cli_usable_channels = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_wifi_direct_cli_usable_channels(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.WifiLanUsableChannels wifi_lan_usable_channels = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_wifi_lan_usable_channels(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.WifiAwareUsableChannels wifi_aware_usable_channels = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_wifi_aware_usable_channels(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.WifiHotspotStaUsableChannels wifi_hotspot_sta_usable_channels = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_wifi_hotspot_sta_usable_channels(), 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(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* MediumMetadata::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.MediumMetadata) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional bool supports_5_ghz = 1; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_supports_5_ghz(), target); + } + + // optional string bssid = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 2, this->_internal_bssid(), target); + } + + // optional bytes ip_address = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased( + 3, this->_internal_ip_address(), target); + } + + // optional bool supports_6_ghz = 4; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_supports_6_ghz(), target); + } + + // optional bool mobile_radio = 5; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_mobile_radio(), target); + } + + // optional int32 ap_frequency = 6 [default = -1]; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_ap_frequency(), target); + } + + // optional .location.nearby.connections.AvailableChannels available_channels = 7; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::available_channels(this), target, stream); + } + + // optional .location.nearby.connections.WifiDirectCliUsableChannels wifi_direct_cli_usable_channels = 8; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::wifi_direct_cli_usable_channels(this), target, stream); + } + + // optional .location.nearby.connections.WifiLanUsableChannels wifi_lan_usable_channels = 9; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::wifi_lan_usable_channels(this), target, stream); + } + + // optional .location.nearby.connections.WifiAwareUsableChannels wifi_aware_usable_channels = 10; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::wifi_aware_usable_channels(this), target, stream); + } + + // optional .location.nearby.connections.WifiHotspotStaUsableChannels wifi_hotspot_sta_usable_channels = 11; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::wifi_hotspot_sta_usable_channels(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.MediumMetadata) + return target; +} + +size_t MediumMetadata::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.MediumMetadata) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string bssid = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_bssid()); + } + + // optional bytes ip_address = 3; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_ip_address()); + } + + // optional .location.nearby.connections.AvailableChannels available_channels = 7; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *available_channels_); + } + + // optional .location.nearby.connections.WifiDirectCliUsableChannels wifi_direct_cli_usable_channels = 8; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *wifi_direct_cli_usable_channels_); + } + + // optional .location.nearby.connections.WifiLanUsableChannels wifi_lan_usable_channels = 9; + if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *wifi_lan_usable_channels_); + } + + // optional .location.nearby.connections.WifiAwareUsableChannels wifi_aware_usable_channels = 10; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *wifi_aware_usable_channels_); + } + + // optional .location.nearby.connections.WifiHotspotStaUsableChannels wifi_hotspot_sta_usable_channels = 11; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *wifi_hotspot_sta_usable_channels_); + } + + // optional bool supports_5_ghz = 1; + if (cached_has_bits & 0x00000080u) { + total_size += 1 + 1; + } + + } + if (cached_has_bits & 0x00000700u) { + // optional bool supports_6_ghz = 4; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 1; + } + + // optional bool mobile_radio = 5; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 1; + } + + // optional int32 ap_frequency = 6 [default = -1]; + if (cached_has_bits & 0x00000400u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_ap_frequency()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MediumMetadata::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void MediumMetadata::MergeFrom(const MediumMetadata& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.MediumMetadata) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_bssid(from._internal_bssid()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_ip_address(from._internal_ip_address()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_available_channels()->::location::nearby::connections::AvailableChannels::MergeFrom(from._internal_available_channels()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_wifi_direct_cli_usable_channels()->::location::nearby::connections::WifiDirectCliUsableChannels::MergeFrom(from._internal_wifi_direct_cli_usable_channels()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_wifi_lan_usable_channels()->::location::nearby::connections::WifiLanUsableChannels::MergeFrom(from._internal_wifi_lan_usable_channels()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_wifi_aware_usable_channels()->::location::nearby::connections::WifiAwareUsableChannels::MergeFrom(from._internal_wifi_aware_usable_channels()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_wifi_hotspot_sta_usable_channels()->::location::nearby::connections::WifiHotspotStaUsableChannels::MergeFrom(from._internal_wifi_hotspot_sta_usable_channels()); + } + if (cached_has_bits & 0x00000080u) { + supports_5_ghz_ = from.supports_5_ghz_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000100u) { + supports_6_ghz_ = from.supports_6_ghz_; + } + if (cached_has_bits & 0x00000200u) { + mobile_radio_ = from.mobile_radio_; + } + if (cached_has_bits & 0x00000400u) { + ap_frequency_ = from.ap_frequency_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void MediumMetadata::CopyFrom(const MediumMetadata& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.MediumMetadata) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MediumMetadata::IsInitialized() const { + return true; +} + +void MediumMetadata::InternalSwap(MediumMetadata* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &bssid_, lhs_arena, + &other->bssid_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &ip_address_, lhs_arena, + &other->ip_address_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MediumMetadata, mobile_radio_) + + sizeof(MediumMetadata::mobile_radio_) + - PROTOBUF_FIELD_OFFSET(MediumMetadata, available_channels_)>( + reinterpret_cast(&available_channels_), + reinterpret_cast(&other->available_channels_)); + swap(ap_frequency_, other->ap_frequency_); +} + +std::string MediumMetadata::GetTypeName() const { + return "location.nearby.connections.MediumMetadata"; +} + + +// =================================================================== + +class AvailableChannels::_Internal { + public: +}; + +AvailableChannels::AvailableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + channels_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.AvailableChannels) +} +AvailableChannels::AvailableChannels(const AvailableChannels& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + channels_(from.channels_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.AvailableChannels) +} + +inline void AvailableChannels::SharedCtor() { +} + +AvailableChannels::~AvailableChannels() { + // @@protoc_insertion_point(destructor:location.nearby.connections.AvailableChannels) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void AvailableChannels::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void AvailableChannels::ArenaDtor(void* object) { + AvailableChannels* _this = reinterpret_cast< AvailableChannels* >(object); + (void)_this; +} +void AvailableChannels::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AvailableChannels::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AvailableChannels::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.AvailableChannels) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + channels_.Clear(); + _internal_metadata_.Clear(); +} + +const char* AvailableChannels::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int32 channels = 1 [packed = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_channels(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 8) { + _internal_add_channels(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* AvailableChannels::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.AvailableChannels) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + int byte_size = _channels_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 1, _internal_channels(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.AvailableChannels) + return target; +} + +size_t AvailableChannels::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.AvailableChannels) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->channels_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _channels_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AvailableChannels::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void AvailableChannels::MergeFrom(const AvailableChannels& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.AvailableChannels) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + channels_.MergeFrom(from.channels_); + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void AvailableChannels::CopyFrom(const AvailableChannels& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.AvailableChannels) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AvailableChannels::IsInitialized() const { + return true; +} + +void AvailableChannels::InternalSwap(AvailableChannels* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + channels_.InternalSwap(&other->channels_); +} + +std::string AvailableChannels::GetTypeName() const { + return "location.nearby.connections.AvailableChannels"; +} + + +// =================================================================== + +class WifiDirectCliUsableChannels::_Internal { + public: +}; + +WifiDirectCliUsableChannels::WifiDirectCliUsableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + channels_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.WifiDirectCliUsableChannels) +} +WifiDirectCliUsableChannels::WifiDirectCliUsableChannels(const WifiDirectCliUsableChannels& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + channels_(from.channels_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.WifiDirectCliUsableChannels) +} + +inline void WifiDirectCliUsableChannels::SharedCtor() { +} + +WifiDirectCliUsableChannels::~WifiDirectCliUsableChannels() { + // @@protoc_insertion_point(destructor:location.nearby.connections.WifiDirectCliUsableChannels) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void WifiDirectCliUsableChannels::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void WifiDirectCliUsableChannels::ArenaDtor(void* object) { + WifiDirectCliUsableChannels* _this = reinterpret_cast< WifiDirectCliUsableChannels* >(object); + (void)_this; +} +void WifiDirectCliUsableChannels::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void WifiDirectCliUsableChannels::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void WifiDirectCliUsableChannels::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.WifiDirectCliUsableChannels) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + channels_.Clear(); + _internal_metadata_.Clear(); +} + +const char* WifiDirectCliUsableChannels::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int32 channels = 1 [packed = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_channels(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 8) { + _internal_add_channels(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* WifiDirectCliUsableChannels::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.WifiDirectCliUsableChannels) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + int byte_size = _channels_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 1, _internal_channels(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.WifiDirectCliUsableChannels) + return target; +} + +size_t WifiDirectCliUsableChannels::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.WifiDirectCliUsableChannels) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->channels_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _channels_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void WifiDirectCliUsableChannels::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void WifiDirectCliUsableChannels::MergeFrom(const WifiDirectCliUsableChannels& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.WifiDirectCliUsableChannels) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + channels_.MergeFrom(from.channels_); + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void WifiDirectCliUsableChannels::CopyFrom(const WifiDirectCliUsableChannels& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.WifiDirectCliUsableChannels) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WifiDirectCliUsableChannels::IsInitialized() const { + return true; +} + +void WifiDirectCliUsableChannels::InternalSwap(WifiDirectCliUsableChannels* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + channels_.InternalSwap(&other->channels_); +} + +std::string WifiDirectCliUsableChannels::GetTypeName() const { + return "location.nearby.connections.WifiDirectCliUsableChannels"; +} + + +// =================================================================== + +class WifiLanUsableChannels::_Internal { + public: +}; + +WifiLanUsableChannels::WifiLanUsableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + channels_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.WifiLanUsableChannels) +} +WifiLanUsableChannels::WifiLanUsableChannels(const WifiLanUsableChannels& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + channels_(from.channels_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.WifiLanUsableChannels) +} + +inline void WifiLanUsableChannels::SharedCtor() { +} + +WifiLanUsableChannels::~WifiLanUsableChannels() { + // @@protoc_insertion_point(destructor:location.nearby.connections.WifiLanUsableChannels) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void WifiLanUsableChannels::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void WifiLanUsableChannels::ArenaDtor(void* object) { + WifiLanUsableChannels* _this = reinterpret_cast< WifiLanUsableChannels* >(object); + (void)_this; +} +void WifiLanUsableChannels::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void WifiLanUsableChannels::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void WifiLanUsableChannels::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.WifiLanUsableChannels) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + channels_.Clear(); + _internal_metadata_.Clear(); +} + +const char* WifiLanUsableChannels::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int32 channels = 1 [packed = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_channels(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 8) { + _internal_add_channels(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* WifiLanUsableChannels::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.WifiLanUsableChannels) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + int byte_size = _channels_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 1, _internal_channels(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.WifiLanUsableChannels) + return target; +} + +size_t WifiLanUsableChannels::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.WifiLanUsableChannels) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->channels_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _channels_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void WifiLanUsableChannels::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void WifiLanUsableChannels::MergeFrom(const WifiLanUsableChannels& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.WifiLanUsableChannels) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + channels_.MergeFrom(from.channels_); + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void WifiLanUsableChannels::CopyFrom(const WifiLanUsableChannels& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.WifiLanUsableChannels) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WifiLanUsableChannels::IsInitialized() const { + return true; +} + +void WifiLanUsableChannels::InternalSwap(WifiLanUsableChannels* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + channels_.InternalSwap(&other->channels_); +} + +std::string WifiLanUsableChannels::GetTypeName() const { + return "location.nearby.connections.WifiLanUsableChannels"; +} + + +// =================================================================== + +class WifiAwareUsableChannels::_Internal { + public: +}; + +WifiAwareUsableChannels::WifiAwareUsableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + channels_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.WifiAwareUsableChannels) +} +WifiAwareUsableChannels::WifiAwareUsableChannels(const WifiAwareUsableChannels& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + channels_(from.channels_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.WifiAwareUsableChannels) +} + +inline void WifiAwareUsableChannels::SharedCtor() { +} + +WifiAwareUsableChannels::~WifiAwareUsableChannels() { + // @@protoc_insertion_point(destructor:location.nearby.connections.WifiAwareUsableChannels) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void WifiAwareUsableChannels::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void WifiAwareUsableChannels::ArenaDtor(void* object) { + WifiAwareUsableChannels* _this = reinterpret_cast< WifiAwareUsableChannels* >(object); + (void)_this; +} +void WifiAwareUsableChannels::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void WifiAwareUsableChannels::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void WifiAwareUsableChannels::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.WifiAwareUsableChannels) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + channels_.Clear(); + _internal_metadata_.Clear(); +} + +const char* WifiAwareUsableChannels::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int32 channels = 1 [packed = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_channels(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 8) { + _internal_add_channels(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* WifiAwareUsableChannels::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.WifiAwareUsableChannels) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + int byte_size = _channels_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 1, _internal_channels(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.WifiAwareUsableChannels) + return target; +} + +size_t WifiAwareUsableChannels::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.WifiAwareUsableChannels) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->channels_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _channels_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void WifiAwareUsableChannels::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void WifiAwareUsableChannels::MergeFrom(const WifiAwareUsableChannels& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.WifiAwareUsableChannels) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + channels_.MergeFrom(from.channels_); + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void WifiAwareUsableChannels::CopyFrom(const WifiAwareUsableChannels& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.WifiAwareUsableChannels) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WifiAwareUsableChannels::IsInitialized() const { + return true; +} + +void WifiAwareUsableChannels::InternalSwap(WifiAwareUsableChannels* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + channels_.InternalSwap(&other->channels_); +} + +std::string WifiAwareUsableChannels::GetTypeName() const { + return "location.nearby.connections.WifiAwareUsableChannels"; +} + + +// =================================================================== + +class WifiHotspotStaUsableChannels::_Internal { + public: +}; + +WifiHotspotStaUsableChannels::WifiHotspotStaUsableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + channels_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.WifiHotspotStaUsableChannels) +} +WifiHotspotStaUsableChannels::WifiHotspotStaUsableChannels(const WifiHotspotStaUsableChannels& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + channels_(from.channels_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.WifiHotspotStaUsableChannels) +} + +inline void WifiHotspotStaUsableChannels::SharedCtor() { +} + +WifiHotspotStaUsableChannels::~WifiHotspotStaUsableChannels() { + // @@protoc_insertion_point(destructor:location.nearby.connections.WifiHotspotStaUsableChannels) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void WifiHotspotStaUsableChannels::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void WifiHotspotStaUsableChannels::ArenaDtor(void* object) { + WifiHotspotStaUsableChannels* _this = reinterpret_cast< WifiHotspotStaUsableChannels* >(object); + (void)_this; +} +void WifiHotspotStaUsableChannels::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void WifiHotspotStaUsableChannels::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void WifiHotspotStaUsableChannels::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.WifiHotspotStaUsableChannels) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + channels_.Clear(); + _internal_metadata_.Clear(); +} + +const char* WifiHotspotStaUsableChannels::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int32 channels = 1 [packed = true]; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_channels(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 8) { + _internal_add_channels(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* WifiHotspotStaUsableChannels::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.WifiHotspotStaUsableChannels) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + int byte_size = _channels_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 1, _internal_channels(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.WifiHotspotStaUsableChannels) + return target; +} + +size_t WifiHotspotStaUsableChannels::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.WifiHotspotStaUsableChannels) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 channels = 1 [packed = true]; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->channels_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _channels_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void WifiHotspotStaUsableChannels::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void WifiHotspotStaUsableChannels::MergeFrom(const WifiHotspotStaUsableChannels& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.WifiHotspotStaUsableChannels) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + channels_.MergeFrom(from.channels_); + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void WifiHotspotStaUsableChannels::CopyFrom(const WifiHotspotStaUsableChannels& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.WifiHotspotStaUsableChannels) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool WifiHotspotStaUsableChannels::IsInitialized() const { + return true; +} + +void WifiHotspotStaUsableChannels::InternalSwap(WifiHotspotStaUsableChannels* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + channels_.InternalSwap(&other->channels_); +} + +std::string WifiHotspotStaUsableChannels::GetTypeName() const { + return "location.nearby.connections.WifiHotspotStaUsableChannels"; +} + + +// =================================================================== + +class LocationHint::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_location(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_format(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +LocationHint::LocationHint(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.LocationHint) +} +LocationHint::LocationHint(const LocationHint& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + location_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + location_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_location()) { + location_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_location(), + GetArenaForAllocation()); + } + format_ = from.format_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.LocationHint) +} + +inline void LocationHint::SharedCtor() { +location_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + location_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +format_ = 0; +} + +LocationHint::~LocationHint() { + // @@protoc_insertion_point(destructor:location.nearby.connections.LocationHint) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void LocationHint::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + location_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void LocationHint::ArenaDtor(void* object) { + LocationHint* _this = reinterpret_cast< LocationHint* >(object); + (void)_this; +} +void LocationHint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void LocationHint::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void LocationHint::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.LocationHint) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + location_.ClearNonDefaultToEmpty(); + } + format_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* LocationHint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string location = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_location(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.connections.LocationStandard.Format format = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::LocationStandard_Format_IsValid(val))) { + _internal_set_format(static_cast<::location::nearby::connections::LocationStandard_Format>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } 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(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* LocationHint::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.LocationHint) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string location = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_location(), target); + } + + // optional .location.nearby.connections.LocationStandard.Format format = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_format(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.LocationHint) + return target; +} + +size_t LocationHint::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.LocationHint) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string location = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_location()); + } + + // optional .location.nearby.connections.LocationStandard.Format format = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_format()); + } + + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void LocationHint::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void LocationHint::MergeFrom(const LocationHint& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.LocationHint) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_location(from._internal_location()); + } + if (cached_has_bits & 0x00000002u) { + format_ = from.format_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void LocationHint::CopyFrom(const LocationHint& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.LocationHint) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LocationHint::IsInitialized() const { + return true; +} + +void LocationHint::InternalSwap(LocationHint* other) { + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &location_, lhs_arena, + &other->location_, rhs_arena + ); + swap(format_, other->format_); +} + +std::string LocationHint::GetTypeName() const { + return "location.nearby.connections.LocationHint"; +} + + +// =================================================================== + +class LocationStandard::_Internal { + public: +}; + +LocationStandard::LocationStandard(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.LocationStandard) +} +LocationStandard::LocationStandard(const LocationStandard& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.LocationStandard) +} + +inline void LocationStandard::SharedCtor() { +} + +LocationStandard::~LocationStandard() { + // @@protoc_insertion_point(destructor:location.nearby.connections.LocationStandard) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void LocationStandard::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void LocationStandard::ArenaDtor(void* object) { + LocationStandard* _this = reinterpret_cast< LocationStandard* >(object); + (void)_this; +} +void LocationStandard::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void LocationStandard::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void LocationStandard::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.LocationStandard) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +const char* LocationStandard::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* LocationStandard::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.LocationStandard) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.LocationStandard) + return target; +} + +size_t LocationStandard::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.LocationStandard) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void LocationStandard::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void LocationStandard::MergeFrom(const LocationStandard& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.LocationStandard) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void LocationStandard::CopyFrom(const LocationStandard& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.LocationStandard) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LocationStandard::IsInitialized() const { + return true; +} + +void LocationStandard::InternalSwap(LocationStandard* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +std::string LocationStandard::GetTypeName() const { + return "location.nearby.connections.LocationStandard"; +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace connections +} // namespace nearby +} // namespace location +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::location::nearby::connections::OfflineFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::OfflineFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::OfflineFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::V1Frame* Arena::CreateMaybeMessage< ::location::nearby::connections::V1Frame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::V1Frame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::ConnectionRequestFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::ConnectionRequestFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::ConnectionRequestFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::ConnectionResponseFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::ConnectionResponseFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::ConnectionResponseFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* Arena::CreateMaybeMessage< ::location::nearby::connections::PayloadTransferFrame_PayloadHeader >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::PayloadTransferFrame_PayloadHeader >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* Arena::CreateMaybeMessage< ::location::nearby::connections::PayloadTransferFrame_PayloadChunk >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::PayloadTransferFrame_PayloadChunk >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::PayloadTransferFrame_ControlMessage* Arena::CreateMaybeMessage< ::location::nearby::connections::PayloadTransferFrame_ControlMessage >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::PayloadTransferFrame_ControlMessage >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::PayloadTransferFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::PayloadTransferFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::PayloadTransferFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::KeepAliveFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::KeepAliveFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::KeepAliveFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::DisconnectionFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::DisconnectionFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::DisconnectionFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::PairedKeyEncryptionFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::PairedKeyEncryptionFrame >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::PairedKeyEncryptionFrame >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::MediumMetadata* Arena::CreateMaybeMessage< ::location::nearby::connections::MediumMetadata >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::MediumMetadata >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::AvailableChannels* Arena::CreateMaybeMessage< ::location::nearby::connections::AvailableChannels >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::AvailableChannels >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::WifiDirectCliUsableChannels* Arena::CreateMaybeMessage< ::location::nearby::connections::WifiDirectCliUsableChannels >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::WifiDirectCliUsableChannels >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::WifiLanUsableChannels* Arena::CreateMaybeMessage< ::location::nearby::connections::WifiLanUsableChannels >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::WifiLanUsableChannels >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::WifiAwareUsableChannels* Arena::CreateMaybeMessage< ::location::nearby::connections::WifiAwareUsableChannels >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::WifiAwareUsableChannels >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::WifiHotspotStaUsableChannels* Arena::CreateMaybeMessage< ::location::nearby::connections::WifiHotspotStaUsableChannels >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::WifiHotspotStaUsableChannels >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::LocationHint* Arena::CreateMaybeMessage< ::location::nearby::connections::LocationHint >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::LocationHint >(arena); +} +template<> PROTOBUF_NOINLINE ::location::nearby::connections::LocationStandard* Arena::CreateMaybeMessage< ::location::nearby::connections::LocationStandard >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::LocationStandard >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/compiled_proto/connections/cpp/implementation/proto/offline_wire_formats.pb.h b/compiled_proto/connections/cpp/implementation/proto/offline_wire_formats.pb.h new file mode 100644 index 00000000..d9de2a8d --- /dev/null +++ b/compiled_proto/connections/cpp/implementation/proto/offline_wire_formats.pb.h @@ -0,0 +1,11883 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: connections/implementation/proto/offline_wire_formats.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3019000 +#error This file was generated by a newer version of protoc which is +#error incompatible with your Protocol Buffer headers. Please update +#error your headers. +#endif +#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION +#error This file was generated by an older version of protoc which is +#error incompatible with your Protocol Buffer headers. Please +#error regenerate this file with a newer version of protoc. +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[29] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const uint32_t offsets[]; +}; +namespace location { +namespace nearby { +namespace connections { +class AvailableChannels; +struct AvailableChannelsDefaultTypeInternal; +extern AvailableChannelsDefaultTypeInternal _AvailableChannels_default_instance_; +class BandwidthUpgradeNegotiationFrame; +struct BandwidthUpgradeNegotiationFrameDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrameDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_default_instance_; +class BandwidthUpgradeNegotiationFrame_ClientIntroduction; +struct BandwidthUpgradeNegotiationFrame_ClientIntroductionDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrame_ClientIntroductionDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_ClientIntroduction_default_instance_; +class BandwidthUpgradeNegotiationFrame_ClientIntroductionAck; +struct BandwidthUpgradeNegotiationFrame_ClientIntroductionAckDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrame_ClientIntroductionAckDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_ClientIntroductionAck_default_instance_; +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo; +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfoDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrame_UpgradePathInfoDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_default_instance_; +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials; +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentialsDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials_default_instance_; +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials; +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentialsDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials_default_instance_; +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials; +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentialsDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials_default_instance_; +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials; +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentialsDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials_default_instance_; +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials; +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentialsDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentialsDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials_default_instance_; +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket; +struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal; +extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket_default_instance_; +class ConnectionRequestFrame; +struct ConnectionRequestFrameDefaultTypeInternal; +extern ConnectionRequestFrameDefaultTypeInternal _ConnectionRequestFrame_default_instance_; +class ConnectionResponseFrame; +struct ConnectionResponseFrameDefaultTypeInternal; +extern ConnectionResponseFrameDefaultTypeInternal _ConnectionResponseFrame_default_instance_; +class DisconnectionFrame; +struct DisconnectionFrameDefaultTypeInternal; +extern DisconnectionFrameDefaultTypeInternal _DisconnectionFrame_default_instance_; +class KeepAliveFrame; +struct KeepAliveFrameDefaultTypeInternal; +extern KeepAliveFrameDefaultTypeInternal _KeepAliveFrame_default_instance_; +class LocationHint; +struct LocationHintDefaultTypeInternal; +extern LocationHintDefaultTypeInternal _LocationHint_default_instance_; +class LocationStandard; +struct LocationStandardDefaultTypeInternal; +extern LocationStandardDefaultTypeInternal _LocationStandard_default_instance_; +class MediumMetadata; +struct MediumMetadataDefaultTypeInternal; +extern MediumMetadataDefaultTypeInternal _MediumMetadata_default_instance_; +class OfflineFrame; +struct OfflineFrameDefaultTypeInternal; +extern OfflineFrameDefaultTypeInternal _OfflineFrame_default_instance_; +class PairedKeyEncryptionFrame; +struct PairedKeyEncryptionFrameDefaultTypeInternal; +extern PairedKeyEncryptionFrameDefaultTypeInternal _PairedKeyEncryptionFrame_default_instance_; +class PayloadTransferFrame; +struct PayloadTransferFrameDefaultTypeInternal; +extern PayloadTransferFrameDefaultTypeInternal _PayloadTransferFrame_default_instance_; +class PayloadTransferFrame_ControlMessage; +struct PayloadTransferFrame_ControlMessageDefaultTypeInternal; +extern PayloadTransferFrame_ControlMessageDefaultTypeInternal _PayloadTransferFrame_ControlMessage_default_instance_; +class PayloadTransferFrame_PayloadChunk; +struct PayloadTransferFrame_PayloadChunkDefaultTypeInternal; +extern PayloadTransferFrame_PayloadChunkDefaultTypeInternal _PayloadTransferFrame_PayloadChunk_default_instance_; +class PayloadTransferFrame_PayloadHeader; +struct PayloadTransferFrame_PayloadHeaderDefaultTypeInternal; +extern PayloadTransferFrame_PayloadHeaderDefaultTypeInternal _PayloadTransferFrame_PayloadHeader_default_instance_; +class V1Frame; +struct V1FrameDefaultTypeInternal; +extern V1FrameDefaultTypeInternal _V1Frame_default_instance_; +class WifiAwareUsableChannels; +struct WifiAwareUsableChannelsDefaultTypeInternal; +extern WifiAwareUsableChannelsDefaultTypeInternal _WifiAwareUsableChannels_default_instance_; +class WifiDirectCliUsableChannels; +struct WifiDirectCliUsableChannelsDefaultTypeInternal; +extern WifiDirectCliUsableChannelsDefaultTypeInternal _WifiDirectCliUsableChannels_default_instance_; +class WifiHotspotStaUsableChannels; +struct WifiHotspotStaUsableChannelsDefaultTypeInternal; +extern WifiHotspotStaUsableChannelsDefaultTypeInternal _WifiHotspotStaUsableChannels_default_instance_; +class WifiLanUsableChannels; +struct WifiLanUsableChannelsDefaultTypeInternal; +extern WifiLanUsableChannelsDefaultTypeInternal _WifiLanUsableChannels_default_instance_; +} // namespace connections +} // namespace nearby +} // namespace location +PROTOBUF_NAMESPACE_OPEN +template<> ::location::nearby::connections::AvailableChannels* Arena::CreateMaybeMessage<::location::nearby::connections::AvailableChannels>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials>(Arena*); +template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket>(Arena*); +template<> ::location::nearby::connections::ConnectionRequestFrame* Arena::CreateMaybeMessage<::location::nearby::connections::ConnectionRequestFrame>(Arena*); +template<> ::location::nearby::connections::ConnectionResponseFrame* Arena::CreateMaybeMessage<::location::nearby::connections::ConnectionResponseFrame>(Arena*); +template<> ::location::nearby::connections::DisconnectionFrame* Arena::CreateMaybeMessage<::location::nearby::connections::DisconnectionFrame>(Arena*); +template<> ::location::nearby::connections::KeepAliveFrame* Arena::CreateMaybeMessage<::location::nearby::connections::KeepAliveFrame>(Arena*); +template<> ::location::nearby::connections::LocationHint* Arena::CreateMaybeMessage<::location::nearby::connections::LocationHint>(Arena*); +template<> ::location::nearby::connections::LocationStandard* Arena::CreateMaybeMessage<::location::nearby::connections::LocationStandard>(Arena*); +template<> ::location::nearby::connections::MediumMetadata* Arena::CreateMaybeMessage<::location::nearby::connections::MediumMetadata>(Arena*); +template<> ::location::nearby::connections::OfflineFrame* Arena::CreateMaybeMessage<::location::nearby::connections::OfflineFrame>(Arena*); +template<> ::location::nearby::connections::PairedKeyEncryptionFrame* Arena::CreateMaybeMessage<::location::nearby::connections::PairedKeyEncryptionFrame>(Arena*); +template<> ::location::nearby::connections::PayloadTransferFrame* Arena::CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame>(Arena*); +template<> ::location::nearby::connections::PayloadTransferFrame_ControlMessage* Arena::CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame_ControlMessage>(Arena*); +template<> ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* Arena::CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame_PayloadChunk>(Arena*); +template<> ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* Arena::CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame_PayloadHeader>(Arena*); +template<> ::location::nearby::connections::V1Frame* Arena::CreateMaybeMessage<::location::nearby::connections::V1Frame>(Arena*); +template<> ::location::nearby::connections::WifiAwareUsableChannels* Arena::CreateMaybeMessage<::location::nearby::connections::WifiAwareUsableChannels>(Arena*); +template<> ::location::nearby::connections::WifiDirectCliUsableChannels* Arena::CreateMaybeMessage<::location::nearby::connections::WifiDirectCliUsableChannels>(Arena*); +template<> ::location::nearby::connections::WifiHotspotStaUsableChannels* Arena::CreateMaybeMessage<::location::nearby::connections::WifiHotspotStaUsableChannels>(Arena*); +template<> ::location::nearby::connections::WifiLanUsableChannels* Arena::CreateMaybeMessage<::location::nearby::connections::WifiLanUsableChannels>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace location { +namespace nearby { +namespace connections { + +enum OfflineFrame_Version : int { + OfflineFrame_Version_UNKNOWN_VERSION = 0, + OfflineFrame_Version_V1 = 1 +}; +bool OfflineFrame_Version_IsValid(int value); +constexpr OfflineFrame_Version OfflineFrame_Version_Version_MIN = OfflineFrame_Version_UNKNOWN_VERSION; +constexpr OfflineFrame_Version OfflineFrame_Version_Version_MAX = OfflineFrame_Version_V1; +constexpr int OfflineFrame_Version_Version_ARRAYSIZE = OfflineFrame_Version_Version_MAX + 1; + +const std::string& OfflineFrame_Version_Name(OfflineFrame_Version value); +template +inline const std::string& OfflineFrame_Version_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OfflineFrame_Version_Name."); + return OfflineFrame_Version_Name(static_cast(enum_t_value)); +} +bool OfflineFrame_Version_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OfflineFrame_Version* value); +enum V1Frame_FrameType : int { + V1Frame_FrameType_UNKNOWN_FRAME_TYPE = 0, + V1Frame_FrameType_CONNECTION_REQUEST = 1, + V1Frame_FrameType_CONNECTION_RESPONSE = 2, + V1Frame_FrameType_PAYLOAD_TRANSFER = 3, + V1Frame_FrameType_BANDWIDTH_UPGRADE_NEGOTIATION = 4, + V1Frame_FrameType_KEEP_ALIVE = 5, + V1Frame_FrameType_DISCONNECTION = 6, + V1Frame_FrameType_PAIRED_KEY_ENCRYPTION = 7 +}; +bool V1Frame_FrameType_IsValid(int value); +constexpr V1Frame_FrameType V1Frame_FrameType_FrameType_MIN = V1Frame_FrameType_UNKNOWN_FRAME_TYPE; +constexpr V1Frame_FrameType V1Frame_FrameType_FrameType_MAX = V1Frame_FrameType_PAIRED_KEY_ENCRYPTION; +constexpr int V1Frame_FrameType_FrameType_ARRAYSIZE = V1Frame_FrameType_FrameType_MAX + 1; + +const std::string& V1Frame_FrameType_Name(V1Frame_FrameType value); +template +inline const std::string& V1Frame_FrameType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function V1Frame_FrameType_Name."); + return V1Frame_FrameType_Name(static_cast(enum_t_value)); +} +bool V1Frame_FrameType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1Frame_FrameType* value); +enum ConnectionRequestFrame_Medium : int { + ConnectionRequestFrame_Medium_UNKNOWN_MEDIUM = 0, + ConnectionRequestFrame_Medium_MDNS PROTOBUF_DEPRECATED_ENUM = 1, + ConnectionRequestFrame_Medium_BLUETOOTH = 2, + ConnectionRequestFrame_Medium_WIFI_HOTSPOT = 3, + ConnectionRequestFrame_Medium_BLE = 4, + ConnectionRequestFrame_Medium_WIFI_LAN = 5, + ConnectionRequestFrame_Medium_WIFI_AWARE = 6, + ConnectionRequestFrame_Medium_NFC = 7, + ConnectionRequestFrame_Medium_WIFI_DIRECT = 8, + ConnectionRequestFrame_Medium_WEB_RTC = 9, + ConnectionRequestFrame_Medium_BLE_L2CAP = 10, + ConnectionRequestFrame_Medium_USB = 11 +}; +bool ConnectionRequestFrame_Medium_IsValid(int value); +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame_Medium_Medium_MIN = ConnectionRequestFrame_Medium_UNKNOWN_MEDIUM; +constexpr ConnectionRequestFrame_Medium ConnectionRequestFrame_Medium_Medium_MAX = ConnectionRequestFrame_Medium_USB; +constexpr int ConnectionRequestFrame_Medium_Medium_ARRAYSIZE = ConnectionRequestFrame_Medium_Medium_MAX + 1; + +const std::string& ConnectionRequestFrame_Medium_Name(ConnectionRequestFrame_Medium value); +template +inline const std::string& ConnectionRequestFrame_Medium_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ConnectionRequestFrame_Medium_Name."); + return ConnectionRequestFrame_Medium_Name(static_cast(enum_t_value)); +} +bool ConnectionRequestFrame_Medium_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionRequestFrame_Medium* value); +enum ConnectionResponseFrame_ResponseStatus : int { + ConnectionResponseFrame_ResponseStatus_UNKNOWN_RESPONSE_STATUS = 0, + ConnectionResponseFrame_ResponseStatus_ACCEPT = 1, + ConnectionResponseFrame_ResponseStatus_REJECT = 2 +}; +bool ConnectionResponseFrame_ResponseStatus_IsValid(int value); +constexpr ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame_ResponseStatus_ResponseStatus_MIN = ConnectionResponseFrame_ResponseStatus_UNKNOWN_RESPONSE_STATUS; +constexpr ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame_ResponseStatus_ResponseStatus_MAX = ConnectionResponseFrame_ResponseStatus_REJECT; +constexpr int ConnectionResponseFrame_ResponseStatus_ResponseStatus_ARRAYSIZE = ConnectionResponseFrame_ResponseStatus_ResponseStatus_MAX + 1; + +const std::string& ConnectionResponseFrame_ResponseStatus_Name(ConnectionResponseFrame_ResponseStatus value); +template +inline const std::string& ConnectionResponseFrame_ResponseStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ConnectionResponseFrame_ResponseStatus_Name."); + return ConnectionResponseFrame_ResponseStatus_Name(static_cast(enum_t_value)); +} +bool ConnectionResponseFrame_ResponseStatus_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionResponseFrame_ResponseStatus* value); +enum PayloadTransferFrame_PayloadHeader_PayloadType : int { + PayloadTransferFrame_PayloadHeader_PayloadType_UNKNOWN_PAYLOAD_TYPE = 0, + PayloadTransferFrame_PayloadHeader_PayloadType_BYTES = 1, + PayloadTransferFrame_PayloadHeader_PayloadType_FILE = 2, + PayloadTransferFrame_PayloadHeader_PayloadType_STREAM = 3 +}; +bool PayloadTransferFrame_PayloadHeader_PayloadType_IsValid(int value); +constexpr PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader_PayloadType_PayloadType_MIN = PayloadTransferFrame_PayloadHeader_PayloadType_UNKNOWN_PAYLOAD_TYPE; +constexpr PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader_PayloadType_PayloadType_MAX = PayloadTransferFrame_PayloadHeader_PayloadType_STREAM; +constexpr int PayloadTransferFrame_PayloadHeader_PayloadType_PayloadType_ARRAYSIZE = PayloadTransferFrame_PayloadHeader_PayloadType_PayloadType_MAX + 1; + +const std::string& PayloadTransferFrame_PayloadHeader_PayloadType_Name(PayloadTransferFrame_PayloadHeader_PayloadType value); +template +inline const std::string& PayloadTransferFrame_PayloadHeader_PayloadType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PayloadTransferFrame_PayloadHeader_PayloadType_Name."); + return PayloadTransferFrame_PayloadHeader_PayloadType_Name(static_cast(enum_t_value)); +} +bool PayloadTransferFrame_PayloadHeader_PayloadType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_PayloadHeader_PayloadType* value); +enum PayloadTransferFrame_PayloadChunk_Flags : int { + PayloadTransferFrame_PayloadChunk_Flags_LAST_CHUNK = 1 +}; +bool PayloadTransferFrame_PayloadChunk_Flags_IsValid(int value); +constexpr PayloadTransferFrame_PayloadChunk_Flags PayloadTransferFrame_PayloadChunk_Flags_Flags_MIN = PayloadTransferFrame_PayloadChunk_Flags_LAST_CHUNK; +constexpr PayloadTransferFrame_PayloadChunk_Flags PayloadTransferFrame_PayloadChunk_Flags_Flags_MAX = PayloadTransferFrame_PayloadChunk_Flags_LAST_CHUNK; +constexpr int PayloadTransferFrame_PayloadChunk_Flags_Flags_ARRAYSIZE = PayloadTransferFrame_PayloadChunk_Flags_Flags_MAX + 1; + +const std::string& PayloadTransferFrame_PayloadChunk_Flags_Name(PayloadTransferFrame_PayloadChunk_Flags value); +template +inline const std::string& PayloadTransferFrame_PayloadChunk_Flags_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PayloadTransferFrame_PayloadChunk_Flags_Name."); + return PayloadTransferFrame_PayloadChunk_Flags_Name(static_cast(enum_t_value)); +} +bool PayloadTransferFrame_PayloadChunk_Flags_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_PayloadChunk_Flags* value); +enum PayloadTransferFrame_ControlMessage_EventType : int { + PayloadTransferFrame_ControlMessage_EventType_UNKNOWN_EVENT_TYPE = 0, + PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_ERROR = 1, + PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_CANCELED = 2 +}; +bool PayloadTransferFrame_ControlMessage_EventType_IsValid(int value); +constexpr PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage_EventType_EventType_MIN = PayloadTransferFrame_ControlMessage_EventType_UNKNOWN_EVENT_TYPE; +constexpr PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage_EventType_EventType_MAX = PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_CANCELED; +constexpr int PayloadTransferFrame_ControlMessage_EventType_EventType_ARRAYSIZE = PayloadTransferFrame_ControlMessage_EventType_EventType_MAX + 1; + +const std::string& PayloadTransferFrame_ControlMessage_EventType_Name(PayloadTransferFrame_ControlMessage_EventType value); +template +inline const std::string& PayloadTransferFrame_ControlMessage_EventType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PayloadTransferFrame_ControlMessage_EventType_Name."); + return PayloadTransferFrame_ControlMessage_EventType_Name(static_cast(enum_t_value)); +} +bool PayloadTransferFrame_ControlMessage_EventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_ControlMessage_EventType* value); +enum PayloadTransferFrame_PacketType : int { + PayloadTransferFrame_PacketType_UNKNOWN_PACKET_TYPE = 0, + PayloadTransferFrame_PacketType_DATA = 1, + PayloadTransferFrame_PacketType_CONTROL = 2 +}; +bool PayloadTransferFrame_PacketType_IsValid(int value); +constexpr PayloadTransferFrame_PacketType PayloadTransferFrame_PacketType_PacketType_MIN = PayloadTransferFrame_PacketType_UNKNOWN_PACKET_TYPE; +constexpr PayloadTransferFrame_PacketType PayloadTransferFrame_PacketType_PacketType_MAX = PayloadTransferFrame_PacketType_CONTROL; +constexpr int PayloadTransferFrame_PacketType_PacketType_ARRAYSIZE = PayloadTransferFrame_PacketType_PacketType_MAX + 1; + +const std::string& PayloadTransferFrame_PacketType_Name(PayloadTransferFrame_PacketType value); +template +inline const std::string& PayloadTransferFrame_PacketType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PayloadTransferFrame_PacketType_Name."); + return PayloadTransferFrame_PacketType_Name(static_cast(enum_t_value)); +} +bool PayloadTransferFrame_PacketType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_PacketType* value); +enum BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium : int { + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_UNKNOWN_MEDIUM = 0, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_MDNS PROTOBUF_DEPRECATED_ENUM = 1, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_BLUETOOTH = 2, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WIFI_HOTSPOT = 3, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_BLE = 4, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WIFI_LAN = 5, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WIFI_AWARE = 6, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_NFC = 7, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WIFI_DIRECT = 8, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WEB_RTC = 9, + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_USB = 11 +}; +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_IsValid(int value); +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Medium_MIN = BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_UNKNOWN_MEDIUM; +constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Medium_MAX = BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_USB; +constexpr int BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Medium_ARRAYSIZE = BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Medium_MAX + 1; + +const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Name(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium value); +template +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Name."); + return BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Name(static_cast(enum_t_value)); +} +bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium* value); +enum BandwidthUpgradeNegotiationFrame_EventType : int { + BandwidthUpgradeNegotiationFrame_EventType_UNKNOWN_EVENT_TYPE = 0, + BandwidthUpgradeNegotiationFrame_EventType_UPGRADE_PATH_AVAILABLE = 1, + BandwidthUpgradeNegotiationFrame_EventType_LAST_WRITE_TO_PRIOR_CHANNEL = 2, + BandwidthUpgradeNegotiationFrame_EventType_SAFE_TO_CLOSE_PRIOR_CHANNEL = 3, + BandwidthUpgradeNegotiationFrame_EventType_CLIENT_INTRODUCTION = 4, + BandwidthUpgradeNegotiationFrame_EventType_UPGRADE_FAILURE = 5, + BandwidthUpgradeNegotiationFrame_EventType_CLIENT_INTRODUCTION_ACK = 6 +}; +bool BandwidthUpgradeNegotiationFrame_EventType_IsValid(int value); +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame_EventType_EventType_MIN = BandwidthUpgradeNegotiationFrame_EventType_UNKNOWN_EVENT_TYPE; +constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame_EventType_EventType_MAX = BandwidthUpgradeNegotiationFrame_EventType_CLIENT_INTRODUCTION_ACK; +constexpr int BandwidthUpgradeNegotiationFrame_EventType_EventType_ARRAYSIZE = BandwidthUpgradeNegotiationFrame_EventType_EventType_MAX + 1; + +const std::string& BandwidthUpgradeNegotiationFrame_EventType_Name(BandwidthUpgradeNegotiationFrame_EventType value); +template +inline const std::string& BandwidthUpgradeNegotiationFrame_EventType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function BandwidthUpgradeNegotiationFrame_EventType_Name."); + return BandwidthUpgradeNegotiationFrame_EventType_Name(static_cast(enum_t_value)); +} +bool BandwidthUpgradeNegotiationFrame_EventType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeNegotiationFrame_EventType* value); +enum LocationStandard_Format : int { + LocationStandard_Format_UNKNOWN = 0, + LocationStandard_Format_E164_CALLING = 1, + LocationStandard_Format_ISO_3166_1_ALPHA_2 = 2 +}; +bool LocationStandard_Format_IsValid(int value); +constexpr LocationStandard_Format LocationStandard_Format_Format_MIN = LocationStandard_Format_UNKNOWN; +constexpr LocationStandard_Format LocationStandard_Format_Format_MAX = LocationStandard_Format_ISO_3166_1_ALPHA_2; +constexpr int LocationStandard_Format_Format_ARRAYSIZE = LocationStandard_Format_Format_MAX + 1; + +const std::string& LocationStandard_Format_Name(LocationStandard_Format value); +template +inline const std::string& LocationStandard_Format_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function LocationStandard_Format_Name."); + return LocationStandard_Format_Name(static_cast(enum_t_value)); +} +bool LocationStandard_Format_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LocationStandard_Format* value); +// =================================================================== + +class OfflineFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.OfflineFrame) */ { + public: + inline OfflineFrame() : OfflineFrame(nullptr) {} + ~OfflineFrame() override; + explicit constexpr OfflineFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + OfflineFrame(const OfflineFrame& from); + OfflineFrame(OfflineFrame&& from) noexcept + : OfflineFrame() { + *this = ::std::move(from); + } + + inline OfflineFrame& operator=(const OfflineFrame& from) { + CopyFrom(from); + return *this; + } + inline OfflineFrame& operator=(OfflineFrame&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const OfflineFrame& default_instance() { + return *internal_default_instance(); + } + static inline const OfflineFrame* internal_default_instance() { + return reinterpret_cast( + &_OfflineFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(OfflineFrame& a, OfflineFrame& b) { + a.Swap(&b); + } + inline void Swap(OfflineFrame* 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(OfflineFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + OfflineFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const OfflineFrame& from); + void MergeFrom(const OfflineFrame& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(OfflineFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.OfflineFrame"; + } + protected: + explicit OfflineFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef OfflineFrame_Version Version; + static constexpr Version UNKNOWN_VERSION = + OfflineFrame_Version_UNKNOWN_VERSION; + static constexpr Version V1 = + OfflineFrame_Version_V1; + static inline bool Version_IsValid(int value) { + return OfflineFrame_Version_IsValid(value); + } + static constexpr Version Version_MIN = + OfflineFrame_Version_Version_MIN; + static constexpr Version Version_MAX = + OfflineFrame_Version_Version_MAX; + static constexpr int Version_ARRAYSIZE = + OfflineFrame_Version_Version_ARRAYSIZE; + template + static inline const std::string& Version_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Version_Name."); + return OfflineFrame_Version_Name(enum_t_value); + } + static inline bool Version_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Version* value) { + return OfflineFrame_Version_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kV1FieldNumber = 2, + kVersionFieldNumber = 1, + }; + // optional .location.nearby.connections.V1Frame v1 = 2; + bool has_v1() const; + private: + bool _internal_has_v1() const; + public: + void clear_v1(); + const ::location::nearby::connections::V1Frame& v1() const; + PROTOBUF_NODISCARD ::location::nearby::connections::V1Frame* release_v1(); + ::location::nearby::connections::V1Frame* mutable_v1(); + void set_allocated_v1(::location::nearby::connections::V1Frame* v1); + private: + const ::location::nearby::connections::V1Frame& _internal_v1() const; + ::location::nearby::connections::V1Frame* _internal_mutable_v1(); + public: + void unsafe_arena_set_allocated_v1( + ::location::nearby::connections::V1Frame* v1); + ::location::nearby::connections::V1Frame* unsafe_arena_release_v1(); + + // optional .location.nearby.connections.OfflineFrame.Version version = 1; + bool has_version() const; + private: + bool _internal_has_version() const; + public: + void clear_version(); + ::location::nearby::connections::OfflineFrame_Version version() const; + void set_version(::location::nearby::connections::OfflineFrame_Version value); + private: + ::location::nearby::connections::OfflineFrame_Version _internal_version() const; + void _internal_set_version(::location::nearby::connections::OfflineFrame_Version value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.OfflineFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::location::nearby::connections::V1Frame* v1_; + int version_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class V1Frame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.V1Frame) */ { + public: + inline V1Frame() : V1Frame(nullptr) {} + ~V1Frame() override; + explicit constexpr V1Frame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + V1Frame(const V1Frame& from); + V1Frame(V1Frame&& from) noexcept + : V1Frame() { + *this = ::std::move(from); + } + + inline V1Frame& operator=(const V1Frame& from) { + CopyFrom(from); + return *this; + } + inline V1Frame& operator=(V1Frame&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const V1Frame& default_instance() { + return *internal_default_instance(); + } + static inline const V1Frame* internal_default_instance() { + return reinterpret_cast( + &_V1Frame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(V1Frame& a, V1Frame& b) { + a.Swap(&b); + } + inline void Swap(V1Frame* 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(V1Frame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + V1Frame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const V1Frame& from); + void MergeFrom(const V1Frame& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(V1Frame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.V1Frame"; + } + protected: + explicit V1Frame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef V1Frame_FrameType FrameType; + static constexpr FrameType UNKNOWN_FRAME_TYPE = + V1Frame_FrameType_UNKNOWN_FRAME_TYPE; + static constexpr FrameType CONNECTION_REQUEST = + V1Frame_FrameType_CONNECTION_REQUEST; + static constexpr FrameType CONNECTION_RESPONSE = + V1Frame_FrameType_CONNECTION_RESPONSE; + static constexpr FrameType PAYLOAD_TRANSFER = + V1Frame_FrameType_PAYLOAD_TRANSFER; + static constexpr FrameType BANDWIDTH_UPGRADE_NEGOTIATION = + V1Frame_FrameType_BANDWIDTH_UPGRADE_NEGOTIATION; + static constexpr FrameType KEEP_ALIVE = + V1Frame_FrameType_KEEP_ALIVE; + static constexpr FrameType DISCONNECTION = + V1Frame_FrameType_DISCONNECTION; + static constexpr FrameType PAIRED_KEY_ENCRYPTION = + V1Frame_FrameType_PAIRED_KEY_ENCRYPTION; + static inline bool FrameType_IsValid(int value) { + return V1Frame_FrameType_IsValid(value); + } + static constexpr FrameType FrameType_MIN = + V1Frame_FrameType_FrameType_MIN; + static constexpr FrameType FrameType_MAX = + V1Frame_FrameType_FrameType_MAX; + static constexpr int FrameType_ARRAYSIZE = + V1Frame_FrameType_FrameType_ARRAYSIZE; + template + static inline const std::string& FrameType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function FrameType_Name."); + return V1Frame_FrameType_Name(enum_t_value); + } + static inline bool FrameType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + FrameType* value) { + return V1Frame_FrameType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kConnectionRequestFieldNumber = 2, + kConnectionResponseFieldNumber = 3, + kPayloadTransferFieldNumber = 4, + kBandwidthUpgradeNegotiationFieldNumber = 5, + kKeepAliveFieldNumber = 6, + kDisconnectionFieldNumber = 7, + kPairedKeyEncryptionFieldNumber = 8, + kTypeFieldNumber = 1, + }; + // optional .location.nearby.connections.ConnectionRequestFrame connection_request = 2; + bool has_connection_request() const; + private: + bool _internal_has_connection_request() const; + public: + void clear_connection_request(); + const ::location::nearby::connections::ConnectionRequestFrame& connection_request() const; + PROTOBUF_NODISCARD ::location::nearby::connections::ConnectionRequestFrame* release_connection_request(); + ::location::nearby::connections::ConnectionRequestFrame* mutable_connection_request(); + void set_allocated_connection_request(::location::nearby::connections::ConnectionRequestFrame* connection_request); + private: + const ::location::nearby::connections::ConnectionRequestFrame& _internal_connection_request() const; + ::location::nearby::connections::ConnectionRequestFrame* _internal_mutable_connection_request(); + public: + void unsafe_arena_set_allocated_connection_request( + ::location::nearby::connections::ConnectionRequestFrame* connection_request); + ::location::nearby::connections::ConnectionRequestFrame* unsafe_arena_release_connection_request(); + + // optional .location.nearby.connections.ConnectionResponseFrame connection_response = 3; + bool has_connection_response() const; + private: + bool _internal_has_connection_response() const; + public: + void clear_connection_response(); + const ::location::nearby::connections::ConnectionResponseFrame& connection_response() const; + PROTOBUF_NODISCARD ::location::nearby::connections::ConnectionResponseFrame* release_connection_response(); + ::location::nearby::connections::ConnectionResponseFrame* mutable_connection_response(); + void set_allocated_connection_response(::location::nearby::connections::ConnectionResponseFrame* connection_response); + private: + const ::location::nearby::connections::ConnectionResponseFrame& _internal_connection_response() const; + ::location::nearby::connections::ConnectionResponseFrame* _internal_mutable_connection_response(); + public: + void unsafe_arena_set_allocated_connection_response( + ::location::nearby::connections::ConnectionResponseFrame* connection_response); + ::location::nearby::connections::ConnectionResponseFrame* unsafe_arena_release_connection_response(); + + // optional .location.nearby.connections.PayloadTransferFrame payload_transfer = 4; + bool has_payload_transfer() const; + private: + bool _internal_has_payload_transfer() const; + public: + void clear_payload_transfer(); + const ::location::nearby::connections::PayloadTransferFrame& payload_transfer() const; + PROTOBUF_NODISCARD ::location::nearby::connections::PayloadTransferFrame* release_payload_transfer(); + ::location::nearby::connections::PayloadTransferFrame* mutable_payload_transfer(); + void set_allocated_payload_transfer(::location::nearby::connections::PayloadTransferFrame* payload_transfer); + private: + const ::location::nearby::connections::PayloadTransferFrame& _internal_payload_transfer() const; + ::location::nearby::connections::PayloadTransferFrame* _internal_mutable_payload_transfer(); + public: + void unsafe_arena_set_allocated_payload_transfer( + ::location::nearby::connections::PayloadTransferFrame* payload_transfer); + ::location::nearby::connections::PayloadTransferFrame* unsafe_arena_release_payload_transfer(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame bandwidth_upgrade_negotiation = 5; + bool has_bandwidth_upgrade_negotiation() const; + private: + bool _internal_has_bandwidth_upgrade_negotiation() const; + public: + void clear_bandwidth_upgrade_negotiation(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame& bandwidth_upgrade_negotiation() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* release_bandwidth_upgrade_negotiation(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* mutable_bandwidth_upgrade_negotiation(); + void set_allocated_bandwidth_upgrade_negotiation(::location::nearby::connections::BandwidthUpgradeNegotiationFrame* bandwidth_upgrade_negotiation); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame& _internal_bandwidth_upgrade_negotiation() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* _internal_mutable_bandwidth_upgrade_negotiation(); + public: + void unsafe_arena_set_allocated_bandwidth_upgrade_negotiation( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* bandwidth_upgrade_negotiation); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* unsafe_arena_release_bandwidth_upgrade_negotiation(); + + // optional .location.nearby.connections.KeepAliveFrame keep_alive = 6; + bool has_keep_alive() const; + private: + bool _internal_has_keep_alive() const; + public: + void clear_keep_alive(); + const ::location::nearby::connections::KeepAliveFrame& keep_alive() const; + PROTOBUF_NODISCARD ::location::nearby::connections::KeepAliveFrame* release_keep_alive(); + ::location::nearby::connections::KeepAliveFrame* mutable_keep_alive(); + void set_allocated_keep_alive(::location::nearby::connections::KeepAliveFrame* keep_alive); + private: + const ::location::nearby::connections::KeepAliveFrame& _internal_keep_alive() const; + ::location::nearby::connections::KeepAliveFrame* _internal_mutable_keep_alive(); + public: + void unsafe_arena_set_allocated_keep_alive( + ::location::nearby::connections::KeepAliveFrame* keep_alive); + ::location::nearby::connections::KeepAliveFrame* unsafe_arena_release_keep_alive(); + + // optional .location.nearby.connections.DisconnectionFrame disconnection = 7; + bool has_disconnection() const; + private: + bool _internal_has_disconnection() const; + public: + void clear_disconnection(); + const ::location::nearby::connections::DisconnectionFrame& disconnection() const; + PROTOBUF_NODISCARD ::location::nearby::connections::DisconnectionFrame* release_disconnection(); + ::location::nearby::connections::DisconnectionFrame* mutable_disconnection(); + void set_allocated_disconnection(::location::nearby::connections::DisconnectionFrame* disconnection); + private: + const ::location::nearby::connections::DisconnectionFrame& _internal_disconnection() const; + ::location::nearby::connections::DisconnectionFrame* _internal_mutable_disconnection(); + public: + void unsafe_arena_set_allocated_disconnection( + ::location::nearby::connections::DisconnectionFrame* disconnection); + ::location::nearby::connections::DisconnectionFrame* unsafe_arena_release_disconnection(); + + // optional .location.nearby.connections.PairedKeyEncryptionFrame paired_key_encryption = 8; + bool has_paired_key_encryption() const; + private: + bool _internal_has_paired_key_encryption() const; + public: + void clear_paired_key_encryption(); + const ::location::nearby::connections::PairedKeyEncryptionFrame& paired_key_encryption() const; + PROTOBUF_NODISCARD ::location::nearby::connections::PairedKeyEncryptionFrame* release_paired_key_encryption(); + ::location::nearby::connections::PairedKeyEncryptionFrame* mutable_paired_key_encryption(); + void set_allocated_paired_key_encryption(::location::nearby::connections::PairedKeyEncryptionFrame* paired_key_encryption); + private: + const ::location::nearby::connections::PairedKeyEncryptionFrame& _internal_paired_key_encryption() const; + ::location::nearby::connections::PairedKeyEncryptionFrame* _internal_mutable_paired_key_encryption(); + public: + void unsafe_arena_set_allocated_paired_key_encryption( + ::location::nearby::connections::PairedKeyEncryptionFrame* paired_key_encryption); + ::location::nearby::connections::PairedKeyEncryptionFrame* unsafe_arena_release_paired_key_encryption(); + + // optional .location.nearby.connections.V1Frame.FrameType type = 1; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::location::nearby::connections::V1Frame_FrameType type() const; + void set_type(::location::nearby::connections::V1Frame_FrameType value); + private: + ::location::nearby::connections::V1Frame_FrameType _internal_type() const; + void _internal_set_type(::location::nearby::connections::V1Frame_FrameType value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.V1Frame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::location::nearby::connections::ConnectionRequestFrame* connection_request_; + ::location::nearby::connections::ConnectionResponseFrame* connection_response_; + ::location::nearby::connections::PayloadTransferFrame* payload_transfer_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* bandwidth_upgrade_negotiation_; + ::location::nearby::connections::KeepAliveFrame* keep_alive_; + ::location::nearby::connections::DisconnectionFrame* disconnection_; + ::location::nearby::connections::PairedKeyEncryptionFrame* paired_key_encryption_; + int type_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class ConnectionRequestFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.ConnectionRequestFrame) */ { + public: + inline ConnectionRequestFrame() : ConnectionRequestFrame(nullptr) {} + ~ConnectionRequestFrame() override; + explicit constexpr ConnectionRequestFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ConnectionRequestFrame(const ConnectionRequestFrame& from); + ConnectionRequestFrame(ConnectionRequestFrame&& from) noexcept + : ConnectionRequestFrame() { + *this = ::std::move(from); + } + + inline ConnectionRequestFrame& operator=(const ConnectionRequestFrame& from) { + CopyFrom(from); + return *this; + } + inline ConnectionRequestFrame& operator=(ConnectionRequestFrame&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ConnectionRequestFrame& default_instance() { + return *internal_default_instance(); + } + static inline const ConnectionRequestFrame* internal_default_instance() { + return reinterpret_cast( + &_ConnectionRequestFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(ConnectionRequestFrame& a, ConnectionRequestFrame& b) { + a.Swap(&b); + } + inline void Swap(ConnectionRequestFrame* 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(ConnectionRequestFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ConnectionRequestFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ConnectionRequestFrame& from); + void MergeFrom(const ConnectionRequestFrame& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ConnectionRequestFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.ConnectionRequestFrame"; + } + protected: + explicit ConnectionRequestFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef ConnectionRequestFrame_Medium Medium; + static constexpr Medium UNKNOWN_MEDIUM = + ConnectionRequestFrame_Medium_UNKNOWN_MEDIUM; + PROTOBUF_DEPRECATED_ENUM static constexpr Medium MDNS = + ConnectionRequestFrame_Medium_MDNS; + static constexpr Medium BLUETOOTH = + ConnectionRequestFrame_Medium_BLUETOOTH; + static constexpr Medium WIFI_HOTSPOT = + ConnectionRequestFrame_Medium_WIFI_HOTSPOT; + static constexpr Medium BLE = + ConnectionRequestFrame_Medium_BLE; + static constexpr Medium WIFI_LAN = + ConnectionRequestFrame_Medium_WIFI_LAN; + static constexpr Medium WIFI_AWARE = + ConnectionRequestFrame_Medium_WIFI_AWARE; + static constexpr Medium NFC = + ConnectionRequestFrame_Medium_NFC; + static constexpr Medium WIFI_DIRECT = + ConnectionRequestFrame_Medium_WIFI_DIRECT; + static constexpr Medium WEB_RTC = + ConnectionRequestFrame_Medium_WEB_RTC; + static constexpr Medium BLE_L2CAP = + ConnectionRequestFrame_Medium_BLE_L2CAP; + static constexpr Medium USB = + ConnectionRequestFrame_Medium_USB; + static inline bool Medium_IsValid(int value) { + return ConnectionRequestFrame_Medium_IsValid(value); + } + static constexpr Medium Medium_MIN = + ConnectionRequestFrame_Medium_Medium_MIN; + static constexpr Medium Medium_MAX = + ConnectionRequestFrame_Medium_Medium_MAX; + static constexpr int Medium_ARRAYSIZE = + ConnectionRequestFrame_Medium_Medium_ARRAYSIZE; + template + static inline const std::string& Medium_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Medium_Name."); + return ConnectionRequestFrame_Medium_Name(enum_t_value); + } + static inline bool Medium_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Medium* value) { + return ConnectionRequestFrame_Medium_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kMediumsFieldNumber = 5, + kEndpointIdFieldNumber = 1, + kEndpointNameFieldNumber = 2, + kHandshakeDataFieldNumber = 3, + kEndpointInfoFieldNumber = 6, + kDeviceInfoFieldNumber = 11, + kMediumMetadataFieldNumber = 7, + kNonceFieldNumber = 4, + kKeepAliveIntervalMillisFieldNumber = 8, + kKeepAliveTimeoutMillisFieldNumber = 9, + kDeviceTypeFieldNumber = 10, + }; + // repeated .location.nearby.connections.ConnectionRequestFrame.Medium mediums = 5; + int mediums_size() const; + private: + int _internal_mediums_size() const; + public: + void clear_mediums(); + private: + ::location::nearby::connections::ConnectionRequestFrame_Medium _internal_mediums(int index) const; + void _internal_add_mediums(::location::nearby::connections::ConnectionRequestFrame_Medium value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_mediums(); + public: + ::location::nearby::connections::ConnectionRequestFrame_Medium mediums(int index) const; + void set_mediums(int index, ::location::nearby::connections::ConnectionRequestFrame_Medium value); + void add_mediums(::location::nearby::connections::ConnectionRequestFrame_Medium value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& mediums() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_mediums(); + + // optional string endpoint_id = 1; + bool has_endpoint_id() const; + private: + bool _internal_has_endpoint_id() const; + public: + void clear_endpoint_id(); + const std::string& endpoint_id() const; + template + void set_endpoint_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_endpoint_id(); + PROTOBUF_NODISCARD std::string* release_endpoint_id(); + void set_allocated_endpoint_id(std::string* endpoint_id); + private: + const std::string& _internal_endpoint_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_endpoint_id(const std::string& value); + std::string* _internal_mutable_endpoint_id(); + public: + + // optional string endpoint_name = 2; + bool has_endpoint_name() const; + private: + bool _internal_has_endpoint_name() const; + public: + void clear_endpoint_name(); + const std::string& endpoint_name() const; + template + void set_endpoint_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_endpoint_name(); + PROTOBUF_NODISCARD std::string* release_endpoint_name(); + void set_allocated_endpoint_name(std::string* endpoint_name); + private: + const std::string& _internal_endpoint_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_endpoint_name(const std::string& value); + std::string* _internal_mutable_endpoint_name(); + public: + + // optional bytes handshake_data = 3; + bool has_handshake_data() const; + private: + bool _internal_has_handshake_data() const; + public: + void clear_handshake_data(); + const std::string& handshake_data() const; + template + void set_handshake_data(ArgT0&& arg0, ArgT... args); + std::string* mutable_handshake_data(); + PROTOBUF_NODISCARD std::string* release_handshake_data(); + void set_allocated_handshake_data(std::string* handshake_data); + private: + const std::string& _internal_handshake_data() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_handshake_data(const std::string& value); + std::string* _internal_mutable_handshake_data(); + public: + + // optional bytes endpoint_info = 6; + bool has_endpoint_info() const; + private: + bool _internal_has_endpoint_info() const; + public: + void clear_endpoint_info(); + const std::string& endpoint_info() const; + template + void set_endpoint_info(ArgT0&& arg0, ArgT... args); + std::string* mutable_endpoint_info(); + PROTOBUF_NODISCARD std::string* release_endpoint_info(); + void set_allocated_endpoint_info(std::string* endpoint_info); + private: + const std::string& _internal_endpoint_info() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_endpoint_info(const std::string& value); + std::string* _internal_mutable_endpoint_info(); + public: + + // optional bytes device_info = 11; + bool has_device_info() const; + private: + bool _internal_has_device_info() const; + public: + void clear_device_info(); + const std::string& device_info() const; + template + void set_device_info(ArgT0&& arg0, ArgT... args); + std::string* mutable_device_info(); + PROTOBUF_NODISCARD std::string* release_device_info(); + void set_allocated_device_info(std::string* device_info); + private: + const std::string& _internal_device_info() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_info(const std::string& value); + std::string* _internal_mutable_device_info(); + public: + + // optional .location.nearby.connections.MediumMetadata medium_metadata = 7; + bool has_medium_metadata() const; + private: + bool _internal_has_medium_metadata() const; + public: + void clear_medium_metadata(); + const ::location::nearby::connections::MediumMetadata& medium_metadata() const; + PROTOBUF_NODISCARD ::location::nearby::connections::MediumMetadata* release_medium_metadata(); + ::location::nearby::connections::MediumMetadata* mutable_medium_metadata(); + void set_allocated_medium_metadata(::location::nearby::connections::MediumMetadata* medium_metadata); + private: + const ::location::nearby::connections::MediumMetadata& _internal_medium_metadata() const; + ::location::nearby::connections::MediumMetadata* _internal_mutable_medium_metadata(); + public: + void unsafe_arena_set_allocated_medium_metadata( + ::location::nearby::connections::MediumMetadata* medium_metadata); + ::location::nearby::connections::MediumMetadata* unsafe_arena_release_medium_metadata(); + + // optional int32 nonce = 4; + bool has_nonce() const; + private: + bool _internal_has_nonce() const; + public: + void clear_nonce(); + int32_t nonce() const; + void set_nonce(int32_t value); + private: + int32_t _internal_nonce() const; + void _internal_set_nonce(int32_t value); + public: + + // optional int32 keep_alive_interval_millis = 8; + bool has_keep_alive_interval_millis() const; + private: + bool _internal_has_keep_alive_interval_millis() const; + public: + void clear_keep_alive_interval_millis(); + int32_t keep_alive_interval_millis() const; + void set_keep_alive_interval_millis(int32_t value); + private: + int32_t _internal_keep_alive_interval_millis() const; + void _internal_set_keep_alive_interval_millis(int32_t value); + public: + + // optional int32 keep_alive_timeout_millis = 9; + bool has_keep_alive_timeout_millis() const; + private: + bool _internal_has_keep_alive_timeout_millis() const; + public: + void clear_keep_alive_timeout_millis(); + int32_t keep_alive_timeout_millis() const; + void set_keep_alive_timeout_millis(int32_t value); + private: + int32_t _internal_keep_alive_timeout_millis() const; + void _internal_set_keep_alive_timeout_millis(int32_t value); + public: + + // optional int32 device_type = 10 [default = 0]; + bool has_device_type() const; + private: + bool _internal_has_device_type() const; + public: + void clear_device_type(); + int32_t device_type() const; + void set_device_type(int32_t value); + private: + int32_t _internal_device_type() const; + void _internal_set_device_type(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.ConnectionRequestFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField mediums_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr endpoint_id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr endpoint_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr handshake_data_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr endpoint_info_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_info_; + ::location::nearby::connections::MediumMetadata* medium_metadata_; + int32_t nonce_; + int32_t keep_alive_interval_millis_; + int32_t keep_alive_timeout_millis_; + int32_t device_type_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class ConnectionResponseFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.ConnectionResponseFrame) */ { + public: + inline ConnectionResponseFrame() : ConnectionResponseFrame(nullptr) {} + ~ConnectionResponseFrame() override; + explicit constexpr ConnectionResponseFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ConnectionResponseFrame(const ConnectionResponseFrame& from); + ConnectionResponseFrame(ConnectionResponseFrame&& from) noexcept + : ConnectionResponseFrame() { + *this = ::std::move(from); + } + + inline ConnectionResponseFrame& operator=(const ConnectionResponseFrame& from) { + CopyFrom(from); + return *this; + } + inline ConnectionResponseFrame& operator=(ConnectionResponseFrame&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ConnectionResponseFrame& default_instance() { + return *internal_default_instance(); + } + static inline const ConnectionResponseFrame* internal_default_instance() { + return reinterpret_cast( + &_ConnectionResponseFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(ConnectionResponseFrame& a, ConnectionResponseFrame& b) { + a.Swap(&b); + } + inline void Swap(ConnectionResponseFrame* 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(ConnectionResponseFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ConnectionResponseFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ConnectionResponseFrame& from); + void MergeFrom(const ConnectionResponseFrame& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ConnectionResponseFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.ConnectionResponseFrame"; + } + protected: + explicit ConnectionResponseFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef ConnectionResponseFrame_ResponseStatus ResponseStatus; + static constexpr ResponseStatus UNKNOWN_RESPONSE_STATUS = + ConnectionResponseFrame_ResponseStatus_UNKNOWN_RESPONSE_STATUS; + static constexpr ResponseStatus ACCEPT = + ConnectionResponseFrame_ResponseStatus_ACCEPT; + static constexpr ResponseStatus REJECT = + ConnectionResponseFrame_ResponseStatus_REJECT; + static inline bool ResponseStatus_IsValid(int value) { + return ConnectionResponseFrame_ResponseStatus_IsValid(value); + } + static constexpr ResponseStatus ResponseStatus_MIN = + ConnectionResponseFrame_ResponseStatus_ResponseStatus_MIN; + static constexpr ResponseStatus ResponseStatus_MAX = + ConnectionResponseFrame_ResponseStatus_ResponseStatus_MAX; + static constexpr int ResponseStatus_ARRAYSIZE = + ConnectionResponseFrame_ResponseStatus_ResponseStatus_ARRAYSIZE; + template + static inline const std::string& ResponseStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ResponseStatus_Name."); + return ConnectionResponseFrame_ResponseStatus_Name(enum_t_value); + } + static inline bool ResponseStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ResponseStatus* value) { + return ConnectionResponseFrame_ResponseStatus_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kHandshakeDataFieldNumber = 2, + kStatusFieldNumber = 1, + kResponseFieldNumber = 3, + }; + // optional bytes handshake_data = 2; + bool has_handshake_data() const; + private: + bool _internal_has_handshake_data() const; + public: + void clear_handshake_data(); + const std::string& handshake_data() const; + template + void set_handshake_data(ArgT0&& arg0, ArgT... args); + std::string* mutable_handshake_data(); + PROTOBUF_NODISCARD std::string* release_handshake_data(); + void set_allocated_handshake_data(std::string* handshake_data); + private: + const std::string& _internal_handshake_data() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_handshake_data(const std::string& value); + std::string* _internal_mutable_handshake_data(); + public: + + // optional int32 status = 1 [deprecated = true]; + PROTOBUF_DEPRECATED bool has_status() const; + private: + bool _internal_has_status() const; + public: + PROTOBUF_DEPRECATED void clear_status(); + PROTOBUF_DEPRECATED int32_t status() const; + PROTOBUF_DEPRECATED void set_status(int32_t value); + private: + int32_t _internal_status() const; + void _internal_set_status(int32_t value); + public: + + // optional .location.nearby.connections.ConnectionResponseFrame.ResponseStatus response = 3; + bool has_response() const; + private: + bool _internal_has_response() const; + public: + void clear_response(); + ::location::nearby::connections::ConnectionResponseFrame_ResponseStatus response() const; + void set_response(::location::nearby::connections::ConnectionResponseFrame_ResponseStatus value); + private: + ::location::nearby::connections::ConnectionResponseFrame_ResponseStatus _internal_response() const; + void _internal_set_response(::location::nearby::connections::ConnectionResponseFrame_ResponseStatus value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.ConnectionResponseFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr handshake_data_; + int32_t status_; + int response_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class PayloadTransferFrame_PayloadHeader final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.PayloadTransferFrame.PayloadHeader) */ { + public: + inline PayloadTransferFrame_PayloadHeader() : PayloadTransferFrame_PayloadHeader(nullptr) {} + ~PayloadTransferFrame_PayloadHeader() override; + explicit constexpr PayloadTransferFrame_PayloadHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PayloadTransferFrame_PayloadHeader(const PayloadTransferFrame_PayloadHeader& from); + PayloadTransferFrame_PayloadHeader(PayloadTransferFrame_PayloadHeader&& from) noexcept + : PayloadTransferFrame_PayloadHeader() { + *this = ::std::move(from); + } + + inline PayloadTransferFrame_PayloadHeader& operator=(const PayloadTransferFrame_PayloadHeader& from) { + CopyFrom(from); + return *this; + } + inline PayloadTransferFrame_PayloadHeader& operator=(PayloadTransferFrame_PayloadHeader&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const PayloadTransferFrame_PayloadHeader& default_instance() { + return *internal_default_instance(); + } + static inline const PayloadTransferFrame_PayloadHeader* internal_default_instance() { + return reinterpret_cast( + &_PayloadTransferFrame_PayloadHeader_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(PayloadTransferFrame_PayloadHeader& a, PayloadTransferFrame_PayloadHeader& b) { + a.Swap(&b); + } + inline void Swap(PayloadTransferFrame_PayloadHeader* 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(PayloadTransferFrame_PayloadHeader* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PayloadTransferFrame_PayloadHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const PayloadTransferFrame_PayloadHeader& from); + void MergeFrom(const PayloadTransferFrame_PayloadHeader& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PayloadTransferFrame_PayloadHeader* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.PayloadTransferFrame.PayloadHeader"; + } + protected: + explicit PayloadTransferFrame_PayloadHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef PayloadTransferFrame_PayloadHeader_PayloadType PayloadType; + static constexpr PayloadType UNKNOWN_PAYLOAD_TYPE = + PayloadTransferFrame_PayloadHeader_PayloadType_UNKNOWN_PAYLOAD_TYPE; + static constexpr PayloadType BYTES = + PayloadTransferFrame_PayloadHeader_PayloadType_BYTES; + static constexpr PayloadType FILE = + PayloadTransferFrame_PayloadHeader_PayloadType_FILE; + static constexpr PayloadType STREAM = + PayloadTransferFrame_PayloadHeader_PayloadType_STREAM; + static inline bool PayloadType_IsValid(int value) { + return PayloadTransferFrame_PayloadHeader_PayloadType_IsValid(value); + } + static constexpr PayloadType PayloadType_MIN = + PayloadTransferFrame_PayloadHeader_PayloadType_PayloadType_MIN; + static constexpr PayloadType PayloadType_MAX = + PayloadTransferFrame_PayloadHeader_PayloadType_PayloadType_MAX; + static constexpr int PayloadType_ARRAYSIZE = + PayloadTransferFrame_PayloadHeader_PayloadType_PayloadType_ARRAYSIZE; + template + static inline const std::string& PayloadType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PayloadType_Name."); + return PayloadTransferFrame_PayloadHeader_PayloadType_Name(enum_t_value); + } + static inline bool PayloadType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + PayloadType* value) { + return PayloadTransferFrame_PayloadHeader_PayloadType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kFileNameFieldNumber = 5, + kParentFolderFieldNumber = 6, + kIdFieldNumber = 1, + kTotalSizeFieldNumber = 3, + kTypeFieldNumber = 2, + kIsSensitiveFieldNumber = 4, + }; + // optional string file_name = 5; + bool has_file_name() const; + private: + bool _internal_has_file_name() const; + public: + void clear_file_name(); + const std::string& file_name() const; + template + void set_file_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_file_name(); + PROTOBUF_NODISCARD std::string* release_file_name(); + void set_allocated_file_name(std::string* file_name); + private: + const std::string& _internal_file_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_name(const std::string& value); + std::string* _internal_mutable_file_name(); + public: + + // optional string parent_folder = 6; + bool has_parent_folder() const; + private: + bool _internal_has_parent_folder() const; + public: + void clear_parent_folder(); + const std::string& parent_folder() const; + template + void set_parent_folder(ArgT0&& arg0, ArgT... args); + std::string* mutable_parent_folder(); + PROTOBUF_NODISCARD std::string* release_parent_folder(); + void set_allocated_parent_folder(std::string* parent_folder); + private: + const std::string& _internal_parent_folder() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_parent_folder(const std::string& value); + std::string* _internal_mutable_parent_folder(); + public: + + // optional int64 id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + int64_t id() const; + void set_id(int64_t value); + private: + int64_t _internal_id() const; + void _internal_set_id(int64_t value); + public: + + // optional int64 total_size = 3; + bool has_total_size() const; + private: + bool _internal_has_total_size() const; + public: + void clear_total_size(); + int64_t total_size() const; + void set_total_size(int64_t value); + private: + int64_t _internal_total_size() const; + void _internal_set_total_size(int64_t value); + public: + + // optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader.PayloadType type = 2; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType type() const; + void set_type(::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType value); + private: + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType _internal_type() const; + void _internal_set_type(::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType value); + public: + + // optional bool is_sensitive = 4; + bool has_is_sensitive() const; + private: + bool _internal_has_is_sensitive() const; + public: + void clear_is_sensitive(); + bool is_sensitive() const; + void set_is_sensitive(bool value); + private: + bool _internal_is_sensitive() const; + void _internal_set_is_sensitive(bool value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.PayloadTransferFrame.PayloadHeader) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parent_folder_; + int64_t id_; + int64_t total_size_; + int type_; + bool is_sensitive_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class PayloadTransferFrame_PayloadChunk final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.PayloadTransferFrame.PayloadChunk) */ { + public: + inline PayloadTransferFrame_PayloadChunk() : PayloadTransferFrame_PayloadChunk(nullptr) {} + ~PayloadTransferFrame_PayloadChunk() override; + explicit constexpr PayloadTransferFrame_PayloadChunk(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PayloadTransferFrame_PayloadChunk(const PayloadTransferFrame_PayloadChunk& from); + PayloadTransferFrame_PayloadChunk(PayloadTransferFrame_PayloadChunk&& from) noexcept + : PayloadTransferFrame_PayloadChunk() { + *this = ::std::move(from); + } + + inline PayloadTransferFrame_PayloadChunk& operator=(const PayloadTransferFrame_PayloadChunk& from) { + CopyFrom(from); + return *this; + } + inline PayloadTransferFrame_PayloadChunk& operator=(PayloadTransferFrame_PayloadChunk&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const PayloadTransferFrame_PayloadChunk& default_instance() { + return *internal_default_instance(); + } + static inline const PayloadTransferFrame_PayloadChunk* internal_default_instance() { + return reinterpret_cast( + &_PayloadTransferFrame_PayloadChunk_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(PayloadTransferFrame_PayloadChunk& a, PayloadTransferFrame_PayloadChunk& b) { + a.Swap(&b); + } + inline void Swap(PayloadTransferFrame_PayloadChunk* 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(PayloadTransferFrame_PayloadChunk* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PayloadTransferFrame_PayloadChunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const PayloadTransferFrame_PayloadChunk& from); + void MergeFrom(const PayloadTransferFrame_PayloadChunk& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PayloadTransferFrame_PayloadChunk* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.PayloadTransferFrame.PayloadChunk"; + } + protected: + explicit PayloadTransferFrame_PayloadChunk(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef PayloadTransferFrame_PayloadChunk_Flags Flags; + static constexpr Flags LAST_CHUNK = + PayloadTransferFrame_PayloadChunk_Flags_LAST_CHUNK; + static inline bool Flags_IsValid(int value) { + return PayloadTransferFrame_PayloadChunk_Flags_IsValid(value); + } + static constexpr Flags Flags_MIN = + PayloadTransferFrame_PayloadChunk_Flags_Flags_MIN; + static constexpr Flags Flags_MAX = + PayloadTransferFrame_PayloadChunk_Flags_Flags_MAX; + static constexpr int Flags_ARRAYSIZE = + PayloadTransferFrame_PayloadChunk_Flags_Flags_ARRAYSIZE; + template + static inline const std::string& Flags_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Flags_Name."); + return PayloadTransferFrame_PayloadChunk_Flags_Name(enum_t_value); + } + static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Flags* value) { + return PayloadTransferFrame_PayloadChunk_Flags_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kBodyFieldNumber = 3, + kOffsetFieldNumber = 2, + kFlagsFieldNumber = 1, + }; + // optional bytes body = 3; + bool has_body() const; + private: + bool _internal_has_body() const; + public: + void clear_body(); + const std::string& body() const; + template + void set_body(ArgT0&& arg0, ArgT... args); + std::string* mutable_body(); + PROTOBUF_NODISCARD std::string* release_body(); + void set_allocated_body(std::string* body); + private: + const std::string& _internal_body() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value); + std::string* _internal_mutable_body(); + public: + + // optional int64 offset = 2; + bool has_offset() const; + private: + bool _internal_has_offset() const; + public: + void clear_offset(); + int64_t offset() const; + void set_offset(int64_t value); + private: + int64_t _internal_offset() const; + void _internal_set_offset(int64_t value); + public: + + // optional int32 flags = 1; + bool has_flags() const; + private: + bool _internal_has_flags() const; + public: + void clear_flags(); + int32_t flags() const; + void set_flags(int32_t value); + private: + int32_t _internal_flags() const; + void _internal_set_flags(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.PayloadTransferFrame.PayloadChunk) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; + int64_t offset_; + int32_t flags_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class PayloadTransferFrame_ControlMessage final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.PayloadTransferFrame.ControlMessage) */ { + public: + inline PayloadTransferFrame_ControlMessage() : PayloadTransferFrame_ControlMessage(nullptr) {} + ~PayloadTransferFrame_ControlMessage() override; + explicit constexpr PayloadTransferFrame_ControlMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PayloadTransferFrame_ControlMessage(const PayloadTransferFrame_ControlMessage& from); + PayloadTransferFrame_ControlMessage(PayloadTransferFrame_ControlMessage&& from) noexcept + : PayloadTransferFrame_ControlMessage() { + *this = ::std::move(from); + } + + inline PayloadTransferFrame_ControlMessage& operator=(const PayloadTransferFrame_ControlMessage& from) { + CopyFrom(from); + return *this; + } + inline PayloadTransferFrame_ControlMessage& operator=(PayloadTransferFrame_ControlMessage&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const PayloadTransferFrame_ControlMessage& default_instance() { + return *internal_default_instance(); + } + static inline const PayloadTransferFrame_ControlMessage* internal_default_instance() { + return reinterpret_cast( + &_PayloadTransferFrame_ControlMessage_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(PayloadTransferFrame_ControlMessage& a, PayloadTransferFrame_ControlMessage& b) { + a.Swap(&b); + } + inline void Swap(PayloadTransferFrame_ControlMessage* 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(PayloadTransferFrame_ControlMessage* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PayloadTransferFrame_ControlMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const PayloadTransferFrame_ControlMessage& from); + void MergeFrom(const PayloadTransferFrame_ControlMessage& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PayloadTransferFrame_ControlMessage* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.PayloadTransferFrame.ControlMessage"; + } + protected: + explicit PayloadTransferFrame_ControlMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef PayloadTransferFrame_ControlMessage_EventType EventType; + static constexpr EventType UNKNOWN_EVENT_TYPE = + PayloadTransferFrame_ControlMessage_EventType_UNKNOWN_EVENT_TYPE; + static constexpr EventType PAYLOAD_ERROR = + PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_ERROR; + static constexpr EventType PAYLOAD_CANCELED = + PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_CANCELED; + static inline bool EventType_IsValid(int value) { + return PayloadTransferFrame_ControlMessage_EventType_IsValid(value); + } + static constexpr EventType EventType_MIN = + PayloadTransferFrame_ControlMessage_EventType_EventType_MIN; + static constexpr EventType EventType_MAX = + PayloadTransferFrame_ControlMessage_EventType_EventType_MAX; + static constexpr int EventType_ARRAYSIZE = + PayloadTransferFrame_ControlMessage_EventType_EventType_ARRAYSIZE; + template + static inline const std::string& EventType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function EventType_Name."); + return PayloadTransferFrame_ControlMessage_EventType_Name(enum_t_value); + } + static inline bool EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + EventType* value) { + return PayloadTransferFrame_ControlMessage_EventType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kOffsetFieldNumber = 2, + kEventFieldNumber = 1, + }; + // optional int64 offset = 2; + bool has_offset() const; + private: + bool _internal_has_offset() const; + public: + void clear_offset(); + int64_t offset() const; + void set_offset(int64_t value); + private: + int64_t _internal_offset() const; + void _internal_set_offset(int64_t value); + public: + + // optional .location.nearby.connections.PayloadTransferFrame.ControlMessage.EventType event = 1; + bool has_event() const; + private: + bool _internal_has_event() const; + public: + void clear_event(); + ::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType event() const; + void set_event(::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType value); + private: + ::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType _internal_event() const; + void _internal_set_event(::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.PayloadTransferFrame.ControlMessage) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t offset_; + int event_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class PayloadTransferFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.PayloadTransferFrame) */ { + public: + inline PayloadTransferFrame() : PayloadTransferFrame(nullptr) {} + ~PayloadTransferFrame() override; + explicit constexpr PayloadTransferFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PayloadTransferFrame(const PayloadTransferFrame& from); + PayloadTransferFrame(PayloadTransferFrame&& from) noexcept + : PayloadTransferFrame() { + *this = ::std::move(from); + } + + inline PayloadTransferFrame& operator=(const PayloadTransferFrame& from) { + CopyFrom(from); + return *this; + } + inline PayloadTransferFrame& operator=(PayloadTransferFrame&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const PayloadTransferFrame& default_instance() { + return *internal_default_instance(); + } + static inline const PayloadTransferFrame* internal_default_instance() { + return reinterpret_cast( + &_PayloadTransferFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(PayloadTransferFrame& a, PayloadTransferFrame& b) { + a.Swap(&b); + } + inline void Swap(PayloadTransferFrame* 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(PayloadTransferFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PayloadTransferFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const PayloadTransferFrame& from); + void MergeFrom(const PayloadTransferFrame& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PayloadTransferFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.PayloadTransferFrame"; + } + protected: + explicit PayloadTransferFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef PayloadTransferFrame_PayloadHeader PayloadHeader; + typedef PayloadTransferFrame_PayloadChunk PayloadChunk; + typedef PayloadTransferFrame_ControlMessage ControlMessage; + + typedef PayloadTransferFrame_PacketType PacketType; + static constexpr PacketType UNKNOWN_PACKET_TYPE = + PayloadTransferFrame_PacketType_UNKNOWN_PACKET_TYPE; + static constexpr PacketType DATA = + PayloadTransferFrame_PacketType_DATA; + static constexpr PacketType CONTROL = + PayloadTransferFrame_PacketType_CONTROL; + static inline bool PacketType_IsValid(int value) { + return PayloadTransferFrame_PacketType_IsValid(value); + } + static constexpr PacketType PacketType_MIN = + PayloadTransferFrame_PacketType_PacketType_MIN; + static constexpr PacketType PacketType_MAX = + PayloadTransferFrame_PacketType_PacketType_MAX; + static constexpr int PacketType_ARRAYSIZE = + PayloadTransferFrame_PacketType_PacketType_ARRAYSIZE; + template + static inline const std::string& PacketType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function PacketType_Name."); + return PayloadTransferFrame_PacketType_Name(enum_t_value); + } + static inline bool PacketType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + PacketType* value) { + return PayloadTransferFrame_PacketType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kPayloadHeaderFieldNumber = 2, + kPayloadChunkFieldNumber = 3, + kControlMessageFieldNumber = 4, + kPacketTypeFieldNumber = 1, + }; + // optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader payload_header = 2; + bool has_payload_header() const; + private: + bool _internal_has_payload_header() const; + public: + void clear_payload_header(); + const ::location::nearby::connections::PayloadTransferFrame_PayloadHeader& payload_header() const; + PROTOBUF_NODISCARD ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* release_payload_header(); + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* mutable_payload_header(); + void set_allocated_payload_header(::location::nearby::connections::PayloadTransferFrame_PayloadHeader* payload_header); + private: + const ::location::nearby::connections::PayloadTransferFrame_PayloadHeader& _internal_payload_header() const; + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* _internal_mutable_payload_header(); + public: + void unsafe_arena_set_allocated_payload_header( + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* payload_header); + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* unsafe_arena_release_payload_header(); + + // optional .location.nearby.connections.PayloadTransferFrame.PayloadChunk payload_chunk = 3; + bool has_payload_chunk() const; + private: + bool _internal_has_payload_chunk() const; + public: + void clear_payload_chunk(); + const ::location::nearby::connections::PayloadTransferFrame_PayloadChunk& payload_chunk() const; + PROTOBUF_NODISCARD ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* release_payload_chunk(); + ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* mutable_payload_chunk(); + void set_allocated_payload_chunk(::location::nearby::connections::PayloadTransferFrame_PayloadChunk* payload_chunk); + private: + const ::location::nearby::connections::PayloadTransferFrame_PayloadChunk& _internal_payload_chunk() const; + ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* _internal_mutable_payload_chunk(); + public: + void unsafe_arena_set_allocated_payload_chunk( + ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* payload_chunk); + ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* unsafe_arena_release_payload_chunk(); + + // optional .location.nearby.connections.PayloadTransferFrame.ControlMessage control_message = 4; + bool has_control_message() const; + private: + bool _internal_has_control_message() const; + public: + void clear_control_message(); + const ::location::nearby::connections::PayloadTransferFrame_ControlMessage& control_message() const; + PROTOBUF_NODISCARD ::location::nearby::connections::PayloadTransferFrame_ControlMessage* release_control_message(); + ::location::nearby::connections::PayloadTransferFrame_ControlMessage* mutable_control_message(); + void set_allocated_control_message(::location::nearby::connections::PayloadTransferFrame_ControlMessage* control_message); + private: + const ::location::nearby::connections::PayloadTransferFrame_ControlMessage& _internal_control_message() const; + ::location::nearby::connections::PayloadTransferFrame_ControlMessage* _internal_mutable_control_message(); + public: + void unsafe_arena_set_allocated_control_message( + ::location::nearby::connections::PayloadTransferFrame_ControlMessage* control_message); + ::location::nearby::connections::PayloadTransferFrame_ControlMessage* unsafe_arena_release_control_message(); + + // optional .location.nearby.connections.PayloadTransferFrame.PacketType packet_type = 1; + bool has_packet_type() const; + private: + bool _internal_has_packet_type() const; + public: + void clear_packet_type(); + ::location::nearby::connections::PayloadTransferFrame_PacketType packet_type() const; + void set_packet_type(::location::nearby::connections::PayloadTransferFrame_PacketType value); + private: + ::location::nearby::connections::PayloadTransferFrame_PacketType _internal_packet_type() const; + void _internal_set_packet_type(::location::nearby::connections::PayloadTransferFrame_PacketType value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.PayloadTransferFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* payload_header_; + ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* payload_chunk_; + ::location::nearby::connections::PayloadTransferFrame_ControlMessage* control_message_; + int packet_type_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) */ { + public: + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials() : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials(nullptr) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials() override; + explicit constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& from); + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials&& from) noexcept + : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& operator=(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& operator=(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& a, BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* 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(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSsidFieldNumber = 1, + kPasswordFieldNumber = 2, + kGatewayFieldNumber = 4, + kPortFieldNumber = 3, + kFrequencyFieldNumber = 5, + }; + // optional string ssid = 1; + bool has_ssid() const; + private: + bool _internal_has_ssid() const; + public: + void clear_ssid(); + const std::string& ssid() const; + template + void set_ssid(ArgT0&& arg0, ArgT... args); + std::string* mutable_ssid(); + PROTOBUF_NODISCARD std::string* release_ssid(); + void set_allocated_ssid(std::string* ssid); + private: + const std::string& _internal_ssid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_ssid(const std::string& value); + std::string* _internal_mutable_ssid(); + public: + + // optional string password = 2; + bool has_password() const; + private: + bool _internal_has_password() const; + public: + void clear_password(); + const std::string& password() const; + template + void set_password(ArgT0&& arg0, ArgT... args); + std::string* mutable_password(); + PROTOBUF_NODISCARD std::string* release_password(); + void set_allocated_password(std::string* password); + private: + const std::string& _internal_password() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_password(const std::string& value); + std::string* _internal_mutable_password(); + public: + + // optional string gateway = 4 [default = "0.0.0.0"]; + bool has_gateway() const; + private: + bool _internal_has_gateway() const; + public: + void clear_gateway(); + const std::string& gateway() const; + template + void set_gateway(ArgT0&& arg0, ArgT... args); + std::string* mutable_gateway(); + PROTOBUF_NODISCARD std::string* release_gateway(); + void set_allocated_gateway(std::string* gateway); + private: + const std::string& _internal_gateway() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_gateway(const std::string& value); + std::string* _internal_mutable_gateway(); + public: + + // optional int32 port = 3; + bool has_port() const; + private: + bool _internal_has_port() const; + public: + void clear_port(); + int32_t port() const; + void set_port(int32_t value); + private: + int32_t _internal_port() const; + void _internal_set_port(int32_t value); + public: + + // optional int32 frequency = 5 [default = -1]; + bool has_frequency() const; + private: + bool _internal_has_frequency() const; + public: + void clear_frequency(); + int32_t frequency() const; + void set_frequency(int32_t value); + private: + int32_t _internal_frequency() const; + void _internal_set_frequency(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ssid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr password_; + static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_gateway_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gateway_; + int32_t port_; + int32_t frequency_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) */ { + public: + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket() : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket(nullptr) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket() override; + explicit constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& from); + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket&& from) noexcept + : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& operator=(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& operator=(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& a, BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* 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(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIpAddressFieldNumber = 1, + kWifiPortFieldNumber = 2, + }; + // optional bytes ip_address = 1; + bool has_ip_address() const; + private: + bool _internal_has_ip_address() const; + public: + void clear_ip_address(); + const std::string& ip_address() const; + template + void set_ip_address(ArgT0&& arg0, ArgT... args); + std::string* mutable_ip_address(); + PROTOBUF_NODISCARD std::string* release_ip_address(); + void set_allocated_ip_address(std::string* ip_address); + private: + const std::string& _internal_ip_address() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip_address(const std::string& value); + std::string* _internal_mutable_ip_address(); + public: + + // optional int32 wifi_port = 2; + bool has_wifi_port() const; + private: + bool _internal_has_wifi_port() const; + public: + void clear_wifi_port(); + int32_t wifi_port() const; + void set_wifi_port(int32_t value); + private: + int32_t _internal_wifi_port() const; + void _internal_set_wifi_port(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_address_; + int32_t wifi_port_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) */ { + public: + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials() : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials(nullptr) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials() override; + explicit constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& from); + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials&& from) noexcept + : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& operator=(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& operator=(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& a, BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* 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(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kServiceNameFieldNumber = 1, + kMacAddressFieldNumber = 2, + }; + // optional string service_name = 1; + bool has_service_name() const; + private: + bool _internal_has_service_name() const; + public: + void clear_service_name(); + const std::string& service_name() const; + template + void set_service_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_service_name(); + PROTOBUF_NODISCARD std::string* release_service_name(); + void set_allocated_service_name(std::string* service_name); + private: + const std::string& _internal_service_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_name(const std::string& value); + std::string* _internal_mutable_service_name(); + public: + + // optional string mac_address = 2; + bool has_mac_address() const; + private: + bool _internal_has_mac_address() const; + public: + void clear_mac_address(); + const std::string& mac_address() const; + template + void set_mac_address(ArgT0&& arg0, ArgT... args); + std::string* mutable_mac_address(); + PROTOBUF_NODISCARD std::string* release_mac_address(); + void set_allocated_mac_address(std::string* mac_address); + private: + const std::string& _internal_mac_address() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac_address(const std::string& value); + std::string* _internal_mutable_mac_address(); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_address_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) */ { + public: + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials() : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials(nullptr) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials() override; + explicit constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& from); + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials&& from) noexcept + : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& operator=(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& operator=(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& a, BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* 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(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kServiceIdFieldNumber = 1, + kServiceInfoFieldNumber = 2, + kPasswordFieldNumber = 3, + }; + // optional string service_id = 1; + bool has_service_id() const; + private: + bool _internal_has_service_id() const; + public: + void clear_service_id(); + const std::string& service_id() const; + template + void set_service_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_service_id(); + PROTOBUF_NODISCARD std::string* release_service_id(); + void set_allocated_service_id(std::string* service_id); + private: + const std::string& _internal_service_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id(const std::string& value); + std::string* _internal_mutable_service_id(); + public: + + // optional bytes service_info = 2; + bool has_service_info() const; + private: + bool _internal_has_service_info() const; + public: + void clear_service_info(); + const std::string& service_info() const; + template + void set_service_info(ArgT0&& arg0, ArgT... args); + std::string* mutable_service_info(); + PROTOBUF_NODISCARD std::string* release_service_info(); + void set_allocated_service_info(std::string* service_info); + private: + const std::string& _internal_service_info() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_info(const std::string& value); + std::string* _internal_mutable_service_info(); + public: + + // optional string password = 3; + bool has_password() const; + private: + bool _internal_has_password() const; + public: + void clear_password(); + const std::string& password() const; + template + void set_password(ArgT0&& arg0, ArgT... args); + std::string* mutable_password(); + PROTOBUF_NODISCARD std::string* release_password(); + void set_allocated_password(std::string* password); + private: + const std::string& _internal_password() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_password(const std::string& value); + std::string* _internal_mutable_password(); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_info_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr password_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) */ { + public: + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials() : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials(nullptr) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials() override; + explicit constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& from); + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials&& from) noexcept + : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& operator=(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& operator=(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& a, BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* 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(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSsidFieldNumber = 1, + kPasswordFieldNumber = 2, + kGatewayFieldNumber = 5, + kPortFieldNumber = 3, + kFrequencyFieldNumber = 4, + }; + // optional string ssid = 1; + bool has_ssid() const; + private: + bool _internal_has_ssid() const; + public: + void clear_ssid(); + const std::string& ssid() const; + template + void set_ssid(ArgT0&& arg0, ArgT... args); + std::string* mutable_ssid(); + PROTOBUF_NODISCARD std::string* release_ssid(); + void set_allocated_ssid(std::string* ssid); + private: + const std::string& _internal_ssid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_ssid(const std::string& value); + std::string* _internal_mutable_ssid(); + public: + + // optional string password = 2; + bool has_password() const; + private: + bool _internal_has_password() const; + public: + void clear_password(); + const std::string& password() const; + template + void set_password(ArgT0&& arg0, ArgT... args); + std::string* mutable_password(); + PROTOBUF_NODISCARD std::string* release_password(); + void set_allocated_password(std::string* password); + private: + const std::string& _internal_password() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_password(const std::string& value); + std::string* _internal_mutable_password(); + public: + + // optional string gateway = 5 [default = "0.0.0.0"]; + bool has_gateway() const; + private: + bool _internal_has_gateway() const; + public: + void clear_gateway(); + const std::string& gateway() const; + template + void set_gateway(ArgT0&& arg0, ArgT... args); + std::string* mutable_gateway(); + PROTOBUF_NODISCARD std::string* release_gateway(); + void set_allocated_gateway(std::string* gateway); + private: + const std::string& _internal_gateway() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_gateway(const std::string& value); + std::string* _internal_mutable_gateway(); + public: + + // optional int32 port = 3; + bool has_port() const; + private: + bool _internal_has_port() const; + public: + void clear_port(); + int32_t port() const; + void set_port(int32_t value); + private: + int32_t _internal_port() const; + void _internal_set_port(int32_t value); + public: + + // optional int32 frequency = 4; + bool has_frequency() const; + private: + bool _internal_has_frequency() const; + public: + void clear_frequency(); + int32_t frequency() const; + void set_frequency(int32_t value); + private: + int32_t _internal_frequency() const; + void _internal_set_frequency(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ssid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr password_; + static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_gateway_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gateway_; + int32_t port_; + int32_t frequency_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) */ { + public: + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials() : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials(nullptr) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials() override; + explicit constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& from); + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials&& from) noexcept + : BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& operator=(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& operator=(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& a, BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* 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(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPeerIdFieldNumber = 1, + kLocationHintFieldNumber = 2, + }; + // optional string peer_id = 1; + bool has_peer_id() const; + private: + bool _internal_has_peer_id() const; + public: + void clear_peer_id(); + const std::string& peer_id() const; + template + void set_peer_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_peer_id(); + PROTOBUF_NODISCARD std::string* release_peer_id(); + void set_allocated_peer_id(std::string* peer_id); + private: + const std::string& _internal_peer_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_peer_id(const std::string& value); + std::string* _internal_mutable_peer_id(); + public: + + // optional .location.nearby.connections.LocationHint location_hint = 2; + bool has_location_hint() const; + private: + bool _internal_has_location_hint() const; + public: + void clear_location_hint(); + const ::location::nearby::connections::LocationHint& location_hint() const; + PROTOBUF_NODISCARD ::location::nearby::connections::LocationHint* release_location_hint(); + ::location::nearby::connections::LocationHint* mutable_location_hint(); + void set_allocated_location_hint(::location::nearby::connections::LocationHint* location_hint); + private: + const ::location::nearby::connections::LocationHint& _internal_location_hint() const; + ::location::nearby::connections::LocationHint* _internal_mutable_location_hint(); + public: + void unsafe_arena_set_allocated_location_hint( + ::location::nearby::connections::LocationHint* location_hint); + ::location::nearby::connections::LocationHint* unsafe_arena_release_location_hint(); + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr peer_id_; + ::location::nearby::connections::LocationHint* location_hint_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame_UpgradePathInfo final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) */ { + public: + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo() : BandwidthUpgradeNegotiationFrame_UpgradePathInfo(nullptr) {} + ~BandwidthUpgradeNegotiationFrame_UpgradePathInfo() override; + explicit constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo& from); + BandwidthUpgradeNegotiationFrame_UpgradePathInfo(BandwidthUpgradeNegotiationFrame_UpgradePathInfo&& from) noexcept + : BandwidthUpgradeNegotiationFrame_UpgradePathInfo() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo& operator=(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame_UpgradePathInfo& operator=(BandwidthUpgradeNegotiationFrame_UpgradePathInfo&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame_UpgradePathInfo& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame_UpgradePathInfo* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo& a, BandwidthUpgradeNegotiationFrame_UpgradePathInfo& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo* 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(BandwidthUpgradeNegotiationFrame_UpgradePathInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame_UpgradePathInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame_UpgradePathInfo& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame_UpgradePathInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame_UpgradePathInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials WifiHotspotCredentials; + typedef BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket WifiLanSocket; + typedef BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials BluetoothCredentials; + typedef BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials WifiAwareCredentials; + typedef BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials WifiDirectCredentials; + typedef BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials WebRtcCredentials; + + typedef BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium Medium; + static constexpr Medium UNKNOWN_MEDIUM = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_UNKNOWN_MEDIUM; + PROTOBUF_DEPRECATED_ENUM static constexpr Medium MDNS = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_MDNS; + static constexpr Medium BLUETOOTH = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_BLUETOOTH; + static constexpr Medium WIFI_HOTSPOT = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WIFI_HOTSPOT; + static constexpr Medium BLE = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_BLE; + static constexpr Medium WIFI_LAN = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WIFI_LAN; + static constexpr Medium WIFI_AWARE = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WIFI_AWARE; + static constexpr Medium NFC = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_NFC; + static constexpr Medium WIFI_DIRECT = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WIFI_DIRECT; + static constexpr Medium WEB_RTC = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_WEB_RTC; + static constexpr Medium USB = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_USB; + static inline bool Medium_IsValid(int value) { + return BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_IsValid(value); + } + static constexpr Medium Medium_MIN = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Medium_MIN; + static constexpr Medium Medium_MAX = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Medium_MAX; + static constexpr int Medium_ARRAYSIZE = + BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Medium_ARRAYSIZE; + template + static inline const std::string& Medium_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Medium_Name."); + return BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Name(enum_t_value); + } + static inline bool Medium_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Medium* value) { + return BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kWifiHotspotCredentialsFieldNumber = 2, + kWifiLanSocketFieldNumber = 3, + kBluetoothCredentialsFieldNumber = 4, + kWifiAwareCredentialsFieldNumber = 5, + kWifiDirectCredentialsFieldNumber = 6, + kWebRtcCredentialsFieldNumber = 8, + kMediumFieldNumber = 1, + kSupportsDisablingEncryptionFieldNumber = 7, + kSupportsClientIntroductionAckFieldNumber = 9, + }; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials wifi_hotspot_credentials = 2; + bool has_wifi_hotspot_credentials() const; + private: + bool _internal_has_wifi_hotspot_credentials() const; + public: + void clear_wifi_hotspot_credentials(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& wifi_hotspot_credentials() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* release_wifi_hotspot_credentials(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* mutable_wifi_hotspot_credentials(); + void set_allocated_wifi_hotspot_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* wifi_hotspot_credentials); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& _internal_wifi_hotspot_credentials() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* _internal_mutable_wifi_hotspot_credentials(); + public: + void unsafe_arena_set_allocated_wifi_hotspot_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* wifi_hotspot_credentials); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* unsafe_arena_release_wifi_hotspot_credentials(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket wifi_lan_socket = 3; + bool has_wifi_lan_socket() const; + private: + bool _internal_has_wifi_lan_socket() const; + public: + void clear_wifi_lan_socket(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& wifi_lan_socket() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* release_wifi_lan_socket(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* mutable_wifi_lan_socket(); + void set_allocated_wifi_lan_socket(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* wifi_lan_socket); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& _internal_wifi_lan_socket() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* _internal_mutable_wifi_lan_socket(); + public: + void unsafe_arena_set_allocated_wifi_lan_socket( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* wifi_lan_socket); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* unsafe_arena_release_wifi_lan_socket(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials bluetooth_credentials = 4; + bool has_bluetooth_credentials() const; + private: + bool _internal_has_bluetooth_credentials() const; + public: + void clear_bluetooth_credentials(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& bluetooth_credentials() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* release_bluetooth_credentials(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* mutable_bluetooth_credentials(); + void set_allocated_bluetooth_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* bluetooth_credentials); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& _internal_bluetooth_credentials() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* _internal_mutable_bluetooth_credentials(); + public: + void unsafe_arena_set_allocated_bluetooth_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* bluetooth_credentials); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* unsafe_arena_release_bluetooth_credentials(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials wifi_aware_credentials = 5; + bool has_wifi_aware_credentials() const; + private: + bool _internal_has_wifi_aware_credentials() const; + public: + void clear_wifi_aware_credentials(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& wifi_aware_credentials() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* release_wifi_aware_credentials(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* mutable_wifi_aware_credentials(); + void set_allocated_wifi_aware_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* wifi_aware_credentials); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& _internal_wifi_aware_credentials() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* _internal_mutable_wifi_aware_credentials(); + public: + void unsafe_arena_set_allocated_wifi_aware_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* wifi_aware_credentials); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* unsafe_arena_release_wifi_aware_credentials(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials wifi_direct_credentials = 6; + bool has_wifi_direct_credentials() const; + private: + bool _internal_has_wifi_direct_credentials() const; + public: + void clear_wifi_direct_credentials(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& wifi_direct_credentials() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* release_wifi_direct_credentials(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* mutable_wifi_direct_credentials(); + void set_allocated_wifi_direct_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* wifi_direct_credentials); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& _internal_wifi_direct_credentials() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* _internal_mutable_wifi_direct_credentials(); + public: + void unsafe_arena_set_allocated_wifi_direct_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* wifi_direct_credentials); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* unsafe_arena_release_wifi_direct_credentials(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials web_rtc_credentials = 8; + bool has_web_rtc_credentials() const; + private: + bool _internal_has_web_rtc_credentials() const; + public: + void clear_web_rtc_credentials(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& web_rtc_credentials() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* release_web_rtc_credentials(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* mutable_web_rtc_credentials(); + void set_allocated_web_rtc_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* web_rtc_credentials); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& _internal_web_rtc_credentials() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* _internal_mutable_web_rtc_credentials(); + public: + void unsafe_arena_set_allocated_web_rtc_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* web_rtc_credentials); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* unsafe_arena_release_web_rtc_credentials(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.Medium medium = 1; + bool has_medium() const; + private: + bool _internal_has_medium() const; + public: + void clear_medium(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium medium() const; + void set_medium(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium value); + private: + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium _internal_medium() const; + void _internal_set_medium(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium value); + public: + + // optional bool supports_disabling_encryption = 7; + bool has_supports_disabling_encryption() const; + private: + bool _internal_has_supports_disabling_encryption() const; + public: + void clear_supports_disabling_encryption(); + bool supports_disabling_encryption() const; + void set_supports_disabling_encryption(bool value); + private: + bool _internal_supports_disabling_encryption() const; + void _internal_set_supports_disabling_encryption(bool value); + public: + + // optional bool supports_client_introduction_ack = 9; + bool has_supports_client_introduction_ack() const; + private: + bool _internal_has_supports_client_introduction_ack() const; + public: + void clear_supports_client_introduction_ack(); + bool supports_client_introduction_ack() const; + void set_supports_client_introduction_ack(bool value); + private: + bool _internal_supports_client_introduction_ack() const; + void _internal_set_supports_client_introduction_ack(bool value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* wifi_hotspot_credentials_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* wifi_lan_socket_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* bluetooth_credentials_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* wifi_aware_credentials_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* wifi_direct_credentials_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* web_rtc_credentials_; + int medium_; + bool supports_disabling_encryption_; + bool supports_client_introduction_ack_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame_ClientIntroduction final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) */ { + public: + inline BandwidthUpgradeNegotiationFrame_ClientIntroduction() : BandwidthUpgradeNegotiationFrame_ClientIntroduction(nullptr) {} + ~BandwidthUpgradeNegotiationFrame_ClientIntroduction() override; + explicit constexpr BandwidthUpgradeNegotiationFrame_ClientIntroduction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame_ClientIntroduction(const BandwidthUpgradeNegotiationFrame_ClientIntroduction& from); + BandwidthUpgradeNegotiationFrame_ClientIntroduction(BandwidthUpgradeNegotiationFrame_ClientIntroduction&& from) noexcept + : BandwidthUpgradeNegotiationFrame_ClientIntroduction() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame_ClientIntroduction& operator=(const BandwidthUpgradeNegotiationFrame_ClientIntroduction& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame_ClientIntroduction& operator=(BandwidthUpgradeNegotiationFrame_ClientIntroduction&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame_ClientIntroduction& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame_ClientIntroduction* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_ClientIntroduction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(BandwidthUpgradeNegotiationFrame_ClientIntroduction& a, BandwidthUpgradeNegotiationFrame_ClientIntroduction& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame_ClientIntroduction* 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(BandwidthUpgradeNegotiationFrame_ClientIntroduction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame_ClientIntroduction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame_ClientIntroduction& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame_ClientIntroduction& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame_ClientIntroduction* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame_ClientIntroduction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kEndpointIdFieldNumber = 1, + kSupportsDisablingEncryptionFieldNumber = 2, + }; + // optional string endpoint_id = 1; + bool has_endpoint_id() const; + private: + bool _internal_has_endpoint_id() const; + public: + void clear_endpoint_id(); + const std::string& endpoint_id() const; + template + void set_endpoint_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_endpoint_id(); + PROTOBUF_NODISCARD std::string* release_endpoint_id(); + void set_allocated_endpoint_id(std::string* endpoint_id); + private: + const std::string& _internal_endpoint_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_endpoint_id(const std::string& value); + std::string* _internal_mutable_endpoint_id(); + public: + + // optional bool supports_disabling_encryption = 2; + bool has_supports_disabling_encryption() const; + private: + bool _internal_has_supports_disabling_encryption() const; + public: + void clear_supports_disabling_encryption(); + bool supports_disabling_encryption() const; + void set_supports_disabling_encryption(bool value); + private: + bool _internal_supports_disabling_encryption() const; + void _internal_set_supports_disabling_encryption(bool value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr endpoint_id_; + bool supports_disabling_encryption_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame_ClientIntroductionAck final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) */ { + public: + inline BandwidthUpgradeNegotiationFrame_ClientIntroductionAck() : BandwidthUpgradeNegotiationFrame_ClientIntroductionAck(nullptr) {} + ~BandwidthUpgradeNegotiationFrame_ClientIntroductionAck() override; + explicit constexpr BandwidthUpgradeNegotiationFrame_ClientIntroductionAck(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame_ClientIntroductionAck(const BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& from); + BandwidthUpgradeNegotiationFrame_ClientIntroductionAck(BandwidthUpgradeNegotiationFrame_ClientIntroductionAck&& from) noexcept + : BandwidthUpgradeNegotiationFrame_ClientIntroductionAck() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& operator=(const BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& operator=(BandwidthUpgradeNegotiationFrame_ClientIntroductionAck&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_ClientIntroductionAck_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& a, BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* 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(BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame_ClientIntroductionAck(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class BandwidthUpgradeNegotiationFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeNegotiationFrame) */ { + public: + inline BandwidthUpgradeNegotiationFrame() : BandwidthUpgradeNegotiationFrame(nullptr) {} + ~BandwidthUpgradeNegotiationFrame() override; + explicit constexpr BandwidthUpgradeNegotiationFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + BandwidthUpgradeNegotiationFrame(const BandwidthUpgradeNegotiationFrame& from); + BandwidthUpgradeNegotiationFrame(BandwidthUpgradeNegotiationFrame&& from) noexcept + : BandwidthUpgradeNegotiationFrame() { + *this = ::std::move(from); + } + + inline BandwidthUpgradeNegotiationFrame& operator=(const BandwidthUpgradeNegotiationFrame& from) { + CopyFrom(from); + return *this; + } + inline BandwidthUpgradeNegotiationFrame& operator=(BandwidthUpgradeNegotiationFrame&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BandwidthUpgradeNegotiationFrame& default_instance() { + return *internal_default_instance(); + } + static inline const BandwidthUpgradeNegotiationFrame* internal_default_instance() { + return reinterpret_cast( + &_BandwidthUpgradeNegotiationFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(BandwidthUpgradeNegotiationFrame& a, BandwidthUpgradeNegotiationFrame& b) { + a.Swap(&b); + } + inline void Swap(BandwidthUpgradeNegotiationFrame* 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(BandwidthUpgradeNegotiationFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BandwidthUpgradeNegotiationFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const BandwidthUpgradeNegotiationFrame& from); + void MergeFrom(const BandwidthUpgradeNegotiationFrame& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(BandwidthUpgradeNegotiationFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.BandwidthUpgradeNegotiationFrame"; + } + protected: + explicit BandwidthUpgradeNegotiationFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef BandwidthUpgradeNegotiationFrame_UpgradePathInfo UpgradePathInfo; + typedef BandwidthUpgradeNegotiationFrame_ClientIntroduction ClientIntroduction; + typedef BandwidthUpgradeNegotiationFrame_ClientIntroductionAck ClientIntroductionAck; + + typedef BandwidthUpgradeNegotiationFrame_EventType EventType; + static constexpr EventType UNKNOWN_EVENT_TYPE = + BandwidthUpgradeNegotiationFrame_EventType_UNKNOWN_EVENT_TYPE; + static constexpr EventType UPGRADE_PATH_AVAILABLE = + BandwidthUpgradeNegotiationFrame_EventType_UPGRADE_PATH_AVAILABLE; + static constexpr EventType LAST_WRITE_TO_PRIOR_CHANNEL = + BandwidthUpgradeNegotiationFrame_EventType_LAST_WRITE_TO_PRIOR_CHANNEL; + static constexpr EventType SAFE_TO_CLOSE_PRIOR_CHANNEL = + BandwidthUpgradeNegotiationFrame_EventType_SAFE_TO_CLOSE_PRIOR_CHANNEL; + static constexpr EventType CLIENT_INTRODUCTION = + BandwidthUpgradeNegotiationFrame_EventType_CLIENT_INTRODUCTION; + static constexpr EventType UPGRADE_FAILURE = + BandwidthUpgradeNegotiationFrame_EventType_UPGRADE_FAILURE; + static constexpr EventType CLIENT_INTRODUCTION_ACK = + BandwidthUpgradeNegotiationFrame_EventType_CLIENT_INTRODUCTION_ACK; + static inline bool EventType_IsValid(int value) { + return BandwidthUpgradeNegotiationFrame_EventType_IsValid(value); + } + static constexpr EventType EventType_MIN = + BandwidthUpgradeNegotiationFrame_EventType_EventType_MIN; + static constexpr EventType EventType_MAX = + BandwidthUpgradeNegotiationFrame_EventType_EventType_MAX; + static constexpr int EventType_ARRAYSIZE = + BandwidthUpgradeNegotiationFrame_EventType_EventType_ARRAYSIZE; + template + static inline const std::string& EventType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function EventType_Name."); + return BandwidthUpgradeNegotiationFrame_EventType_Name(enum_t_value); + } + static inline bool EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + EventType* value) { + return BandwidthUpgradeNegotiationFrame_EventType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kUpgradePathInfoFieldNumber = 2, + kClientIntroductionFieldNumber = 3, + kClientIntroductionAckFieldNumber = 4, + kEventTypeFieldNumber = 1, + }; + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo upgrade_path_info = 2; + bool has_upgrade_path_info() const; + private: + bool _internal_has_upgrade_path_info() const; + public: + void clear_upgrade_path_info(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo& upgrade_path_info() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* release_upgrade_path_info(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* mutable_upgrade_path_info(); + void set_allocated_upgrade_path_info(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* upgrade_path_info); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo& _internal_upgrade_path_info() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* _internal_mutable_upgrade_path_info(); + public: + void unsafe_arena_set_allocated_upgrade_path_info( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* upgrade_path_info); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* unsafe_arena_release_upgrade_path_info(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction client_introduction = 3; + bool has_client_introduction() const; + private: + bool _internal_has_client_introduction() const; + public: + void clear_client_introduction(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction& client_introduction() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* release_client_introduction(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* mutable_client_introduction(); + void set_allocated_client_introduction(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* client_introduction); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction& _internal_client_introduction() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* _internal_mutable_client_introduction(); + public: + void unsafe_arena_set_allocated_client_introduction( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* client_introduction); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* unsafe_arena_release_client_introduction(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck client_introduction_ack = 4; + bool has_client_introduction_ack() const; + private: + bool _internal_has_client_introduction_ack() const; + public: + void clear_client_introduction_ack(); + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& client_introduction_ack() const; + PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* release_client_introduction_ack(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* mutable_client_introduction_ack(); + void set_allocated_client_introduction_ack(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* client_introduction_ack); + private: + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& _internal_client_introduction_ack() const; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* _internal_mutable_client_introduction_ack(); + public: + void unsafe_arena_set_allocated_client_introduction_ack( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* client_introduction_ack); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* unsafe_arena_release_client_introduction_ack(); + + // optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.EventType event_type = 1; + bool has_event_type() const; + private: + bool _internal_has_event_type() const; + public: + void clear_event_type(); + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType event_type() const; + void set_event_type(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType value); + private: + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType _internal_event_type() const; + void _internal_set_event_type(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeNegotiationFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* upgrade_path_info_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* client_introduction_; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* client_introduction_ack_; + int event_type_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class KeepAliveFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.KeepAliveFrame) */ { + public: + inline KeepAliveFrame() : KeepAliveFrame(nullptr) {} + ~KeepAliveFrame() override; + explicit constexpr KeepAliveFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + KeepAliveFrame(const KeepAliveFrame& from); + KeepAliveFrame(KeepAliveFrame&& from) noexcept + : KeepAliveFrame() { + *this = ::std::move(from); + } + + inline KeepAliveFrame& operator=(const KeepAliveFrame& from) { + CopyFrom(from); + return *this; + } + inline KeepAliveFrame& operator=(KeepAliveFrame&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const KeepAliveFrame& default_instance() { + return *internal_default_instance(); + } + static inline const KeepAliveFrame* internal_default_instance() { + return reinterpret_cast( + &_KeepAliveFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(KeepAliveFrame& a, KeepAliveFrame& b) { + a.Swap(&b); + } + inline void Swap(KeepAliveFrame* 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(KeepAliveFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + KeepAliveFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const KeepAliveFrame& from); + void MergeFrom(const KeepAliveFrame& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(KeepAliveFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.KeepAliveFrame"; + } + protected: + explicit KeepAliveFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kAckFieldNumber = 1, + }; + // optional bool ack = 1; + bool has_ack() const; + private: + bool _internal_has_ack() const; + public: + void clear_ack(); + bool ack() const; + void set_ack(bool value); + private: + bool _internal_ack() const; + void _internal_set_ack(bool value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.KeepAliveFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + bool ack_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class DisconnectionFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.DisconnectionFrame) */ { + public: + inline DisconnectionFrame() : DisconnectionFrame(nullptr) {} + ~DisconnectionFrame() override; + explicit constexpr DisconnectionFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DisconnectionFrame(const DisconnectionFrame& from); + DisconnectionFrame(DisconnectionFrame&& from) noexcept + : DisconnectionFrame() { + *this = ::std::move(from); + } + + inline DisconnectionFrame& operator=(const DisconnectionFrame& from) { + CopyFrom(from); + return *this; + } + inline DisconnectionFrame& operator=(DisconnectionFrame&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const DisconnectionFrame& default_instance() { + return *internal_default_instance(); + } + static inline const DisconnectionFrame* internal_default_instance() { + return reinterpret_cast( + &_DisconnectionFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(DisconnectionFrame& a, DisconnectionFrame& b) { + a.Swap(&b); + } + inline void Swap(DisconnectionFrame* 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(DisconnectionFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DisconnectionFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const DisconnectionFrame& from); + void MergeFrom(const DisconnectionFrame& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(DisconnectionFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.DisconnectionFrame"; + } + protected: + explicit DisconnectionFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:location.nearby.connections.DisconnectionFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class PairedKeyEncryptionFrame final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.PairedKeyEncryptionFrame) */ { + public: + inline PairedKeyEncryptionFrame() : PairedKeyEncryptionFrame(nullptr) {} + ~PairedKeyEncryptionFrame() override; + explicit constexpr PairedKeyEncryptionFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PairedKeyEncryptionFrame(const PairedKeyEncryptionFrame& from); + PairedKeyEncryptionFrame(PairedKeyEncryptionFrame&& from) noexcept + : PairedKeyEncryptionFrame() { + *this = ::std::move(from); + } + + inline PairedKeyEncryptionFrame& operator=(const PairedKeyEncryptionFrame& from) { + CopyFrom(from); + return *this; + } + inline PairedKeyEncryptionFrame& operator=(PairedKeyEncryptionFrame&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const PairedKeyEncryptionFrame& default_instance() { + return *internal_default_instance(); + } + static inline const PairedKeyEncryptionFrame* internal_default_instance() { + return reinterpret_cast( + &_PairedKeyEncryptionFrame_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(PairedKeyEncryptionFrame& a, PairedKeyEncryptionFrame& b) { + a.Swap(&b); + } + inline void Swap(PairedKeyEncryptionFrame* 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(PairedKeyEncryptionFrame* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PairedKeyEncryptionFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const PairedKeyEncryptionFrame& from); + void MergeFrom(const PairedKeyEncryptionFrame& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(PairedKeyEncryptionFrame* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.PairedKeyEncryptionFrame"; + } + protected: + explicit PairedKeyEncryptionFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSignedDataFieldNumber = 1, + }; + // optional bytes signed_data = 1; + bool has_signed_data() const; + private: + bool _internal_has_signed_data() const; + public: + void clear_signed_data(); + const std::string& signed_data() const; + template + void set_signed_data(ArgT0&& arg0, ArgT... args); + std::string* mutable_signed_data(); + PROTOBUF_NODISCARD std::string* release_signed_data(); + void set_allocated_signed_data(std::string* signed_data); + private: + const std::string& _internal_signed_data() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_signed_data(const std::string& value); + std::string* _internal_mutable_signed_data(); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.PairedKeyEncryptionFrame) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signed_data_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class MediumMetadata final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.MediumMetadata) */ { + public: + inline MediumMetadata() : MediumMetadata(nullptr) {} + ~MediumMetadata() override; + explicit constexpr MediumMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MediumMetadata(const MediumMetadata& from); + MediumMetadata(MediumMetadata&& from) noexcept + : MediumMetadata() { + *this = ::std::move(from); + } + + inline MediumMetadata& operator=(const MediumMetadata& from) { + CopyFrom(from); + return *this; + } + inline MediumMetadata& operator=(MediumMetadata&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const MediumMetadata& default_instance() { + return *internal_default_instance(); + } + static inline const MediumMetadata* internal_default_instance() { + return reinterpret_cast( + &_MediumMetadata_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(MediumMetadata& a, MediumMetadata& b) { + a.Swap(&b); + } + inline void Swap(MediumMetadata* 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(MediumMetadata* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MediumMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const MediumMetadata& from); + void MergeFrom(const MediumMetadata& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(MediumMetadata* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.MediumMetadata"; + } + protected: + explicit MediumMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBssidFieldNumber = 2, + kIpAddressFieldNumber = 3, + kAvailableChannelsFieldNumber = 7, + kWifiDirectCliUsableChannelsFieldNumber = 8, + kWifiLanUsableChannelsFieldNumber = 9, + kWifiAwareUsableChannelsFieldNumber = 10, + kWifiHotspotStaUsableChannelsFieldNumber = 11, + kSupports5GhzFieldNumber = 1, + kSupports6GhzFieldNumber = 4, + kMobileRadioFieldNumber = 5, + kApFrequencyFieldNumber = 6, + }; + // optional string bssid = 2; + bool has_bssid() const; + private: + bool _internal_has_bssid() const; + public: + void clear_bssid(); + const std::string& bssid() const; + template + void set_bssid(ArgT0&& arg0, ArgT... args); + std::string* mutable_bssid(); + PROTOBUF_NODISCARD std::string* release_bssid(); + void set_allocated_bssid(std::string* bssid); + private: + const std::string& _internal_bssid() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_bssid(const std::string& value); + std::string* _internal_mutable_bssid(); + public: + + // optional bytes ip_address = 3; + bool has_ip_address() const; + private: + bool _internal_has_ip_address() const; + public: + void clear_ip_address(); + const std::string& ip_address() const; + template + void set_ip_address(ArgT0&& arg0, ArgT... args); + std::string* mutable_ip_address(); + PROTOBUF_NODISCARD std::string* release_ip_address(); + void set_allocated_ip_address(std::string* ip_address); + private: + const std::string& _internal_ip_address() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_ip_address(const std::string& value); + std::string* _internal_mutable_ip_address(); + public: + + // optional .location.nearby.connections.AvailableChannels available_channels = 7; + bool has_available_channels() const; + private: + bool _internal_has_available_channels() const; + public: + void clear_available_channels(); + const ::location::nearby::connections::AvailableChannels& available_channels() const; + PROTOBUF_NODISCARD ::location::nearby::connections::AvailableChannels* release_available_channels(); + ::location::nearby::connections::AvailableChannels* mutable_available_channels(); + void set_allocated_available_channels(::location::nearby::connections::AvailableChannels* available_channels); + private: + const ::location::nearby::connections::AvailableChannels& _internal_available_channels() const; + ::location::nearby::connections::AvailableChannels* _internal_mutable_available_channels(); + public: + void unsafe_arena_set_allocated_available_channels( + ::location::nearby::connections::AvailableChannels* available_channels); + ::location::nearby::connections::AvailableChannels* unsafe_arena_release_available_channels(); + + // optional .location.nearby.connections.WifiDirectCliUsableChannels wifi_direct_cli_usable_channels = 8; + bool has_wifi_direct_cli_usable_channels() const; + private: + bool _internal_has_wifi_direct_cli_usable_channels() const; + public: + void clear_wifi_direct_cli_usable_channels(); + const ::location::nearby::connections::WifiDirectCliUsableChannels& wifi_direct_cli_usable_channels() const; + PROTOBUF_NODISCARD ::location::nearby::connections::WifiDirectCliUsableChannels* release_wifi_direct_cli_usable_channels(); + ::location::nearby::connections::WifiDirectCliUsableChannels* mutable_wifi_direct_cli_usable_channels(); + void set_allocated_wifi_direct_cli_usable_channels(::location::nearby::connections::WifiDirectCliUsableChannels* wifi_direct_cli_usable_channels); + private: + const ::location::nearby::connections::WifiDirectCliUsableChannels& _internal_wifi_direct_cli_usable_channels() const; + ::location::nearby::connections::WifiDirectCliUsableChannels* _internal_mutable_wifi_direct_cli_usable_channels(); + public: + void unsafe_arena_set_allocated_wifi_direct_cli_usable_channels( + ::location::nearby::connections::WifiDirectCliUsableChannels* wifi_direct_cli_usable_channels); + ::location::nearby::connections::WifiDirectCliUsableChannels* unsafe_arena_release_wifi_direct_cli_usable_channels(); + + // optional .location.nearby.connections.WifiLanUsableChannels wifi_lan_usable_channels = 9; + bool has_wifi_lan_usable_channels() const; + private: + bool _internal_has_wifi_lan_usable_channels() const; + public: + void clear_wifi_lan_usable_channels(); + const ::location::nearby::connections::WifiLanUsableChannels& wifi_lan_usable_channels() const; + PROTOBUF_NODISCARD ::location::nearby::connections::WifiLanUsableChannels* release_wifi_lan_usable_channels(); + ::location::nearby::connections::WifiLanUsableChannels* mutable_wifi_lan_usable_channels(); + void set_allocated_wifi_lan_usable_channels(::location::nearby::connections::WifiLanUsableChannels* wifi_lan_usable_channels); + private: + const ::location::nearby::connections::WifiLanUsableChannels& _internal_wifi_lan_usable_channels() const; + ::location::nearby::connections::WifiLanUsableChannels* _internal_mutable_wifi_lan_usable_channels(); + public: + void unsafe_arena_set_allocated_wifi_lan_usable_channels( + ::location::nearby::connections::WifiLanUsableChannels* wifi_lan_usable_channels); + ::location::nearby::connections::WifiLanUsableChannels* unsafe_arena_release_wifi_lan_usable_channels(); + + // optional .location.nearby.connections.WifiAwareUsableChannels wifi_aware_usable_channels = 10; + bool has_wifi_aware_usable_channels() const; + private: + bool _internal_has_wifi_aware_usable_channels() const; + public: + void clear_wifi_aware_usable_channels(); + const ::location::nearby::connections::WifiAwareUsableChannels& wifi_aware_usable_channels() const; + PROTOBUF_NODISCARD ::location::nearby::connections::WifiAwareUsableChannels* release_wifi_aware_usable_channels(); + ::location::nearby::connections::WifiAwareUsableChannels* mutable_wifi_aware_usable_channels(); + void set_allocated_wifi_aware_usable_channels(::location::nearby::connections::WifiAwareUsableChannels* wifi_aware_usable_channels); + private: + const ::location::nearby::connections::WifiAwareUsableChannels& _internal_wifi_aware_usable_channels() const; + ::location::nearby::connections::WifiAwareUsableChannels* _internal_mutable_wifi_aware_usable_channels(); + public: + void unsafe_arena_set_allocated_wifi_aware_usable_channels( + ::location::nearby::connections::WifiAwareUsableChannels* wifi_aware_usable_channels); + ::location::nearby::connections::WifiAwareUsableChannels* unsafe_arena_release_wifi_aware_usable_channels(); + + // optional .location.nearby.connections.WifiHotspotStaUsableChannels wifi_hotspot_sta_usable_channels = 11; + bool has_wifi_hotspot_sta_usable_channels() const; + private: + bool _internal_has_wifi_hotspot_sta_usable_channels() const; + public: + void clear_wifi_hotspot_sta_usable_channels(); + const ::location::nearby::connections::WifiHotspotStaUsableChannels& wifi_hotspot_sta_usable_channels() const; + PROTOBUF_NODISCARD ::location::nearby::connections::WifiHotspotStaUsableChannels* release_wifi_hotspot_sta_usable_channels(); + ::location::nearby::connections::WifiHotspotStaUsableChannels* mutable_wifi_hotspot_sta_usable_channels(); + void set_allocated_wifi_hotspot_sta_usable_channels(::location::nearby::connections::WifiHotspotStaUsableChannels* wifi_hotspot_sta_usable_channels); + private: + const ::location::nearby::connections::WifiHotspotStaUsableChannels& _internal_wifi_hotspot_sta_usable_channels() const; + ::location::nearby::connections::WifiHotspotStaUsableChannels* _internal_mutable_wifi_hotspot_sta_usable_channels(); + public: + void unsafe_arena_set_allocated_wifi_hotspot_sta_usable_channels( + ::location::nearby::connections::WifiHotspotStaUsableChannels* wifi_hotspot_sta_usable_channels); + ::location::nearby::connections::WifiHotspotStaUsableChannels* unsafe_arena_release_wifi_hotspot_sta_usable_channels(); + + // optional bool supports_5_ghz = 1; + bool has_supports_5_ghz() const; + private: + bool _internal_has_supports_5_ghz() const; + public: + void clear_supports_5_ghz(); + bool supports_5_ghz() const; + void set_supports_5_ghz(bool value); + private: + bool _internal_supports_5_ghz() const; + void _internal_set_supports_5_ghz(bool value); + public: + + // optional bool supports_6_ghz = 4; + bool has_supports_6_ghz() const; + private: + bool _internal_has_supports_6_ghz() const; + public: + void clear_supports_6_ghz(); + bool supports_6_ghz() const; + void set_supports_6_ghz(bool value); + private: + bool _internal_supports_6_ghz() const; + void _internal_set_supports_6_ghz(bool value); + public: + + // optional bool mobile_radio = 5; + bool has_mobile_radio() const; + private: + bool _internal_has_mobile_radio() const; + public: + void clear_mobile_radio(); + bool mobile_radio() const; + void set_mobile_radio(bool value); + private: + bool _internal_mobile_radio() const; + void _internal_set_mobile_radio(bool value); + public: + + // optional int32 ap_frequency = 6 [default = -1]; + bool has_ap_frequency() const; + private: + bool _internal_has_ap_frequency() const; + public: + void clear_ap_frequency(); + int32_t ap_frequency() const; + void set_ap_frequency(int32_t value); + private: + int32_t _internal_ap_frequency() const; + void _internal_set_ap_frequency(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.MediumMetadata) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bssid_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_address_; + ::location::nearby::connections::AvailableChannels* available_channels_; + ::location::nearby::connections::WifiDirectCliUsableChannels* wifi_direct_cli_usable_channels_; + ::location::nearby::connections::WifiLanUsableChannels* wifi_lan_usable_channels_; + ::location::nearby::connections::WifiAwareUsableChannels* wifi_aware_usable_channels_; + ::location::nearby::connections::WifiHotspotStaUsableChannels* wifi_hotspot_sta_usable_channels_; + bool supports_5_ghz_; + bool supports_6_ghz_; + bool mobile_radio_; + int32_t ap_frequency_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class AvailableChannels final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.AvailableChannels) */ { + public: + inline AvailableChannels() : AvailableChannels(nullptr) {} + ~AvailableChannels() override; + explicit constexpr AvailableChannels(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AvailableChannels(const AvailableChannels& from); + AvailableChannels(AvailableChannels&& from) noexcept + : AvailableChannels() { + *this = ::std::move(from); + } + + inline AvailableChannels& operator=(const AvailableChannels& from) { + CopyFrom(from); + return *this; + } + inline AvailableChannels& operator=(AvailableChannels&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const AvailableChannels& default_instance() { + return *internal_default_instance(); + } + static inline const AvailableChannels* internal_default_instance() { + return reinterpret_cast( + &_AvailableChannels_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(AvailableChannels& a, AvailableChannels& b) { + a.Swap(&b); + } + inline void Swap(AvailableChannels* 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(AvailableChannels* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AvailableChannels* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const AvailableChannels& from); + void MergeFrom(const AvailableChannels& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(AvailableChannels* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.AvailableChannels"; + } + protected: + explicit AvailableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChannelsFieldNumber = 1, + }; + // repeated int32 channels = 1 [packed = true]; + int channels_size() const; + private: + int _internal_channels_size() const; + public: + void clear_channels(); + private: + int32_t _internal_channels(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_channels() const; + void _internal_add_channels(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_channels(); + public: + int32_t channels(int index) const; + void set_channels(int index, int32_t value); + void add_channels(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + channels() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_channels(); + + // @@protoc_insertion_point(class_scope:location.nearby.connections.AvailableChannels) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > channels_; + mutable std::atomic _channels_cached_byte_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class WifiDirectCliUsableChannels final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.WifiDirectCliUsableChannels) */ { + public: + inline WifiDirectCliUsableChannels() : WifiDirectCliUsableChannels(nullptr) {} + ~WifiDirectCliUsableChannels() override; + explicit constexpr WifiDirectCliUsableChannels(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + WifiDirectCliUsableChannels(const WifiDirectCliUsableChannels& from); + WifiDirectCliUsableChannels(WifiDirectCliUsableChannels&& from) noexcept + : WifiDirectCliUsableChannels() { + *this = ::std::move(from); + } + + inline WifiDirectCliUsableChannels& operator=(const WifiDirectCliUsableChannels& from) { + CopyFrom(from); + return *this; + } + inline WifiDirectCliUsableChannels& operator=(WifiDirectCliUsableChannels&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const WifiDirectCliUsableChannels& default_instance() { + return *internal_default_instance(); + } + static inline const WifiDirectCliUsableChannels* internal_default_instance() { + return reinterpret_cast( + &_WifiDirectCliUsableChannels_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(WifiDirectCliUsableChannels& a, WifiDirectCliUsableChannels& b) { + a.Swap(&b); + } + inline void Swap(WifiDirectCliUsableChannels* 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(WifiDirectCliUsableChannels* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WifiDirectCliUsableChannels* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const WifiDirectCliUsableChannels& from); + void MergeFrom(const WifiDirectCliUsableChannels& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(WifiDirectCliUsableChannels* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.WifiDirectCliUsableChannels"; + } + protected: + explicit WifiDirectCliUsableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChannelsFieldNumber = 1, + }; + // repeated int32 channels = 1 [packed = true]; + int channels_size() const; + private: + int _internal_channels_size() const; + public: + void clear_channels(); + private: + int32_t _internal_channels(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_channels() const; + void _internal_add_channels(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_channels(); + public: + int32_t channels(int index) const; + void set_channels(int index, int32_t value); + void add_channels(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + channels() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_channels(); + + // @@protoc_insertion_point(class_scope:location.nearby.connections.WifiDirectCliUsableChannels) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > channels_; + mutable std::atomic _channels_cached_byte_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class WifiLanUsableChannels final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.WifiLanUsableChannels) */ { + public: + inline WifiLanUsableChannels() : WifiLanUsableChannels(nullptr) {} + ~WifiLanUsableChannels() override; + explicit constexpr WifiLanUsableChannels(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + WifiLanUsableChannels(const WifiLanUsableChannels& from); + WifiLanUsableChannels(WifiLanUsableChannels&& from) noexcept + : WifiLanUsableChannels() { + *this = ::std::move(from); + } + + inline WifiLanUsableChannels& operator=(const WifiLanUsableChannels& from) { + CopyFrom(from); + return *this; + } + inline WifiLanUsableChannels& operator=(WifiLanUsableChannels&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const WifiLanUsableChannels& default_instance() { + return *internal_default_instance(); + } + static inline const WifiLanUsableChannels* internal_default_instance() { + return reinterpret_cast( + &_WifiLanUsableChannels_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(WifiLanUsableChannels& a, WifiLanUsableChannels& b) { + a.Swap(&b); + } + inline void Swap(WifiLanUsableChannels* 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(WifiLanUsableChannels* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WifiLanUsableChannels* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const WifiLanUsableChannels& from); + void MergeFrom(const WifiLanUsableChannels& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(WifiLanUsableChannels* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.WifiLanUsableChannels"; + } + protected: + explicit WifiLanUsableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChannelsFieldNumber = 1, + }; + // repeated int32 channels = 1 [packed = true]; + int channels_size() const; + private: + int _internal_channels_size() const; + public: + void clear_channels(); + private: + int32_t _internal_channels(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_channels() const; + void _internal_add_channels(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_channels(); + public: + int32_t channels(int index) const; + void set_channels(int index, int32_t value); + void add_channels(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + channels() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_channels(); + + // @@protoc_insertion_point(class_scope:location.nearby.connections.WifiLanUsableChannels) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > channels_; + mutable std::atomic _channels_cached_byte_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class WifiAwareUsableChannels final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.WifiAwareUsableChannels) */ { + public: + inline WifiAwareUsableChannels() : WifiAwareUsableChannels(nullptr) {} + ~WifiAwareUsableChannels() override; + explicit constexpr WifiAwareUsableChannels(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + WifiAwareUsableChannels(const WifiAwareUsableChannels& from); + WifiAwareUsableChannels(WifiAwareUsableChannels&& from) noexcept + : WifiAwareUsableChannels() { + *this = ::std::move(from); + } + + inline WifiAwareUsableChannels& operator=(const WifiAwareUsableChannels& from) { + CopyFrom(from); + return *this; + } + inline WifiAwareUsableChannels& operator=(WifiAwareUsableChannels&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const WifiAwareUsableChannels& default_instance() { + return *internal_default_instance(); + } + static inline const WifiAwareUsableChannels* internal_default_instance() { + return reinterpret_cast( + &_WifiAwareUsableChannels_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(WifiAwareUsableChannels& a, WifiAwareUsableChannels& b) { + a.Swap(&b); + } + inline void Swap(WifiAwareUsableChannels* 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(WifiAwareUsableChannels* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WifiAwareUsableChannels* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const WifiAwareUsableChannels& from); + void MergeFrom(const WifiAwareUsableChannels& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(WifiAwareUsableChannels* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.WifiAwareUsableChannels"; + } + protected: + explicit WifiAwareUsableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChannelsFieldNumber = 1, + }; + // repeated int32 channels = 1 [packed = true]; + int channels_size() const; + private: + int _internal_channels_size() const; + public: + void clear_channels(); + private: + int32_t _internal_channels(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_channels() const; + void _internal_add_channels(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_channels(); + public: + int32_t channels(int index) const; + void set_channels(int index, int32_t value); + void add_channels(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + channels() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_channels(); + + // @@protoc_insertion_point(class_scope:location.nearby.connections.WifiAwareUsableChannels) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > channels_; + mutable std::atomic _channels_cached_byte_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class WifiHotspotStaUsableChannels final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.WifiHotspotStaUsableChannels) */ { + public: + inline WifiHotspotStaUsableChannels() : WifiHotspotStaUsableChannels(nullptr) {} + ~WifiHotspotStaUsableChannels() override; + explicit constexpr WifiHotspotStaUsableChannels(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + WifiHotspotStaUsableChannels(const WifiHotspotStaUsableChannels& from); + WifiHotspotStaUsableChannels(WifiHotspotStaUsableChannels&& from) noexcept + : WifiHotspotStaUsableChannels() { + *this = ::std::move(from); + } + + inline WifiHotspotStaUsableChannels& operator=(const WifiHotspotStaUsableChannels& from) { + CopyFrom(from); + return *this; + } + inline WifiHotspotStaUsableChannels& operator=(WifiHotspotStaUsableChannels&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const WifiHotspotStaUsableChannels& default_instance() { + return *internal_default_instance(); + } + static inline const WifiHotspotStaUsableChannels* internal_default_instance() { + return reinterpret_cast( + &_WifiHotspotStaUsableChannels_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(WifiHotspotStaUsableChannels& a, WifiHotspotStaUsableChannels& b) { + a.Swap(&b); + } + inline void Swap(WifiHotspotStaUsableChannels* 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(WifiHotspotStaUsableChannels* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WifiHotspotStaUsableChannels* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const WifiHotspotStaUsableChannels& from); + void MergeFrom(const WifiHotspotStaUsableChannels& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(WifiHotspotStaUsableChannels* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.WifiHotspotStaUsableChannels"; + } + protected: + explicit WifiHotspotStaUsableChannels(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChannelsFieldNumber = 1, + }; + // repeated int32 channels = 1 [packed = true]; + int channels_size() const; + private: + int _internal_channels_size() const; + public: + void clear_channels(); + private: + int32_t _internal_channels(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + _internal_channels() const; + void _internal_add_channels(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + _internal_mutable_channels(); + public: + int32_t channels(int index) const; + void set_channels(int index, int32_t value); + void add_channels(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& + channels() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* + mutable_channels(); + + // @@protoc_insertion_point(class_scope:location.nearby.connections.WifiHotspotStaUsableChannels) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > channels_; + mutable std::atomic _channels_cached_byte_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class LocationHint final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.LocationHint) */ { + public: + inline LocationHint() : LocationHint(nullptr) {} + ~LocationHint() override; + explicit constexpr LocationHint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LocationHint(const LocationHint& from); + LocationHint(LocationHint&& from) noexcept + : LocationHint() { + *this = ::std::move(from); + } + + inline LocationHint& operator=(const LocationHint& from) { + CopyFrom(from); + return *this; + } + inline LocationHint& operator=(LocationHint&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const LocationHint& default_instance() { + return *internal_default_instance(); + } + static inline const LocationHint* internal_default_instance() { + return reinterpret_cast( + &_LocationHint_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(LocationHint& a, LocationHint& b) { + a.Swap(&b); + } + inline void Swap(LocationHint* 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(LocationHint* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LocationHint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const LocationHint& from); + void MergeFrom(const LocationHint& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LocationHint* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.LocationHint"; + } + protected: + explicit LocationHint(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLocationFieldNumber = 1, + kFormatFieldNumber = 2, + }; + // optional string location = 1; + bool has_location() const; + private: + bool _internal_has_location() const; + public: + void clear_location(); + const std::string& location() const; + template + void set_location(ArgT0&& arg0, ArgT... args); + std::string* mutable_location(); + PROTOBUF_NODISCARD std::string* release_location(); + void set_allocated_location(std::string* location); + private: + const std::string& _internal_location() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_location(const std::string& value); + std::string* _internal_mutable_location(); + public: + + // optional .location.nearby.connections.LocationStandard.Format format = 2; + bool has_format() const; + private: + bool _internal_has_format() const; + public: + void clear_format(); + ::location::nearby::connections::LocationStandard_Format format() const; + void set_format(::location::nearby::connections::LocationStandard_Format value); + private: + ::location::nearby::connections::LocationStandard_Format _internal_format() const; + void _internal_set_format(::location::nearby::connections::LocationStandard_Format value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.LocationHint) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr location_; + int format_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// ------------------------------------------------------------------- + +class LocationStandard final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.LocationStandard) */ { + public: + inline LocationStandard() : LocationStandard(nullptr) {} + ~LocationStandard() override; + explicit constexpr LocationStandard(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + LocationStandard(const LocationStandard& from); + LocationStandard(LocationStandard&& from) noexcept + : LocationStandard() { + *this = ::std::move(from); + } + + inline LocationStandard& operator=(const LocationStandard& from) { + CopyFrom(from); + return *this; + } + inline LocationStandard& operator=(LocationStandard&& 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; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const LocationStandard& default_instance() { + return *internal_default_instance(); + } + static inline const LocationStandard* internal_default_instance() { + return reinterpret_cast( + &_LocationStandard_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(LocationStandard& a, LocationStandard& b) { + a.Swap(&b); + } + inline void Swap(LocationStandard* 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(LocationStandard* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + LocationStandard* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const LocationStandard& from); + void MergeFrom(const LocationStandard& from); + 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 _cached_size_.Get(); } + + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(LocationStandard* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.LocationStandard"; + } + protected: + explicit LocationStandard(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef LocationStandard_Format Format; + static constexpr Format UNKNOWN = + LocationStandard_Format_UNKNOWN; + static constexpr Format E164_CALLING = + LocationStandard_Format_E164_CALLING; + static constexpr Format ISO_3166_1_ALPHA_2 = + LocationStandard_Format_ISO_3166_1_ALPHA_2; + static inline bool Format_IsValid(int value) { + return LocationStandard_Format_IsValid(value); + } + static constexpr Format Format_MIN = + LocationStandard_Format_Format_MIN; + static constexpr Format Format_MAX = + LocationStandard_Format_Format_MAX; + static constexpr int Format_ARRAYSIZE = + LocationStandard_Format_Format_ARRAYSIZE; + template + static inline const std::string& Format_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Format_Name."); + return LocationStandard_Format_Name(enum_t_value); + } + static inline bool Format_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Format* value) { + return LocationStandard_Format_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:location.nearby.connections.LocationStandard) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// OfflineFrame + +// optional .location.nearby.connections.OfflineFrame.Version version = 1; +inline bool OfflineFrame::_internal_has_version() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool OfflineFrame::has_version() const { + return _internal_has_version(); +} +inline void OfflineFrame::clear_version() { + version_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::location::nearby::connections::OfflineFrame_Version OfflineFrame::_internal_version() const { + return static_cast< ::location::nearby::connections::OfflineFrame_Version >(version_); +} +inline ::location::nearby::connections::OfflineFrame_Version OfflineFrame::version() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.OfflineFrame.version) + return _internal_version(); +} +inline void OfflineFrame::_internal_set_version(::location::nearby::connections::OfflineFrame_Version value) { + assert(::location::nearby::connections::OfflineFrame_Version_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + version_ = value; +} +inline void OfflineFrame::set_version(::location::nearby::connections::OfflineFrame_Version value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.OfflineFrame.version) +} + +// optional .location.nearby.connections.V1Frame v1 = 2; +inline bool OfflineFrame::_internal_has_v1() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || v1_ != nullptr); + return value; +} +inline bool OfflineFrame::has_v1() const { + return _internal_has_v1(); +} +inline void OfflineFrame::clear_v1() { + if (v1_ != nullptr) v1_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::location::nearby::connections::V1Frame& OfflineFrame::_internal_v1() const { + const ::location::nearby::connections::V1Frame* p = v1_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_V1Frame_default_instance_); +} +inline const ::location::nearby::connections::V1Frame& OfflineFrame::v1() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.OfflineFrame.v1) + return _internal_v1(); +} +inline void OfflineFrame::unsafe_arena_set_allocated_v1( + ::location::nearby::connections::V1Frame* v1) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(v1_); + } + v1_ = v1; + if (v1) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.OfflineFrame.v1) +} +inline ::location::nearby::connections::V1Frame* OfflineFrame::release_v1() { + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::V1Frame* temp = v1_; + v1_ = 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 ::location::nearby::connections::V1Frame* OfflineFrame::unsafe_arena_release_v1() { + // @@protoc_insertion_point(field_release:location.nearby.connections.OfflineFrame.v1) + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::V1Frame* temp = v1_; + v1_ = nullptr; + return temp; +} +inline ::location::nearby::connections::V1Frame* OfflineFrame::_internal_mutable_v1() { + _has_bits_[0] |= 0x00000001u; + if (v1_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::V1Frame>(GetArenaForAllocation()); + v1_ = p; + } + return v1_; +} +inline ::location::nearby::connections::V1Frame* OfflineFrame::mutable_v1() { + ::location::nearby::connections::V1Frame* _msg = _internal_mutable_v1(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.OfflineFrame.v1) + return _msg; +} +inline void OfflineFrame::set_allocated_v1(::location::nearby::connections::V1Frame* v1) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete v1_; + } + if (v1) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::V1Frame>::GetOwningArena(v1); + if (message_arena != submessage_arena) { + v1 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, v1, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + v1_ = v1; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.OfflineFrame.v1) +} + +// ------------------------------------------------------------------- + +// V1Frame + +// optional .location.nearby.connections.V1Frame.FrameType type = 1; +inline bool V1Frame::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool V1Frame::has_type() const { + return _internal_has_type(); +} +inline void V1Frame::clear_type() { + type_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline ::location::nearby::connections::V1Frame_FrameType V1Frame::_internal_type() const { + return static_cast< ::location::nearby::connections::V1Frame_FrameType >(type_); +} +inline ::location::nearby::connections::V1Frame_FrameType V1Frame::type() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.type) + return _internal_type(); +} +inline void V1Frame::_internal_set_type(::location::nearby::connections::V1Frame_FrameType value) { + assert(::location::nearby::connections::V1Frame_FrameType_IsValid(value)); + _has_bits_[0] |= 0x00000080u; + type_ = value; +} +inline void V1Frame::set_type(::location::nearby::connections::V1Frame_FrameType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.V1Frame.type) +} + +// optional .location.nearby.connections.ConnectionRequestFrame connection_request = 2; +inline bool V1Frame::_internal_has_connection_request() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || connection_request_ != nullptr); + return value; +} +inline bool V1Frame::has_connection_request() const { + return _internal_has_connection_request(); +} +inline void V1Frame::clear_connection_request() { + if (connection_request_ != nullptr) connection_request_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::location::nearby::connections::ConnectionRequestFrame& V1Frame::_internal_connection_request() const { + const ::location::nearby::connections::ConnectionRequestFrame* p = connection_request_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_ConnectionRequestFrame_default_instance_); +} +inline const ::location::nearby::connections::ConnectionRequestFrame& V1Frame::connection_request() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.connection_request) + return _internal_connection_request(); +} +inline void V1Frame::unsafe_arena_set_allocated_connection_request( + ::location::nearby::connections::ConnectionRequestFrame* connection_request) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(connection_request_); + } + connection_request_ = connection_request; + if (connection_request) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.connection_request) +} +inline ::location::nearby::connections::ConnectionRequestFrame* V1Frame::release_connection_request() { + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::ConnectionRequestFrame* temp = connection_request_; + connection_request_ = 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 ::location::nearby::connections::ConnectionRequestFrame* V1Frame::unsafe_arena_release_connection_request() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.connection_request) + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::ConnectionRequestFrame* temp = connection_request_; + connection_request_ = nullptr; + return temp; +} +inline ::location::nearby::connections::ConnectionRequestFrame* V1Frame::_internal_mutable_connection_request() { + _has_bits_[0] |= 0x00000001u; + if (connection_request_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::ConnectionRequestFrame>(GetArenaForAllocation()); + connection_request_ = p; + } + return connection_request_; +} +inline ::location::nearby::connections::ConnectionRequestFrame* V1Frame::mutable_connection_request() { + ::location::nearby::connections::ConnectionRequestFrame* _msg = _internal_mutable_connection_request(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.connection_request) + return _msg; +} +inline void V1Frame::set_allocated_connection_request(::location::nearby::connections::ConnectionRequestFrame* connection_request) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete connection_request_; + } + if (connection_request) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::ConnectionRequestFrame>::GetOwningArena(connection_request); + if (message_arena != submessage_arena) { + connection_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, connection_request, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + connection_request_ = connection_request; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.connection_request) +} + +// optional .location.nearby.connections.ConnectionResponseFrame connection_response = 3; +inline bool V1Frame::_internal_has_connection_response() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || connection_response_ != nullptr); + return value; +} +inline bool V1Frame::has_connection_response() const { + return _internal_has_connection_response(); +} +inline void V1Frame::clear_connection_response() { + if (connection_response_ != nullptr) connection_response_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::location::nearby::connections::ConnectionResponseFrame& V1Frame::_internal_connection_response() const { + const ::location::nearby::connections::ConnectionResponseFrame* p = connection_response_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_ConnectionResponseFrame_default_instance_); +} +inline const ::location::nearby::connections::ConnectionResponseFrame& V1Frame::connection_response() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.connection_response) + return _internal_connection_response(); +} +inline void V1Frame::unsafe_arena_set_allocated_connection_response( + ::location::nearby::connections::ConnectionResponseFrame* connection_response) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(connection_response_); + } + connection_response_ = connection_response; + if (connection_response) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.connection_response) +} +inline ::location::nearby::connections::ConnectionResponseFrame* V1Frame::release_connection_response() { + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::ConnectionResponseFrame* temp = connection_response_; + connection_response_ = 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 ::location::nearby::connections::ConnectionResponseFrame* V1Frame::unsafe_arena_release_connection_response() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.connection_response) + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::ConnectionResponseFrame* temp = connection_response_; + connection_response_ = nullptr; + return temp; +} +inline ::location::nearby::connections::ConnectionResponseFrame* V1Frame::_internal_mutable_connection_response() { + _has_bits_[0] |= 0x00000002u; + if (connection_response_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::ConnectionResponseFrame>(GetArenaForAllocation()); + connection_response_ = p; + } + return connection_response_; +} +inline ::location::nearby::connections::ConnectionResponseFrame* V1Frame::mutable_connection_response() { + ::location::nearby::connections::ConnectionResponseFrame* _msg = _internal_mutable_connection_response(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.connection_response) + return _msg; +} +inline void V1Frame::set_allocated_connection_response(::location::nearby::connections::ConnectionResponseFrame* connection_response) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete connection_response_; + } + if (connection_response) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::ConnectionResponseFrame>::GetOwningArena(connection_response); + if (message_arena != submessage_arena) { + connection_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, connection_response, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + connection_response_ = connection_response; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.connection_response) +} + +// optional .location.nearby.connections.PayloadTransferFrame payload_transfer = 4; +inline bool V1Frame::_internal_has_payload_transfer() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || payload_transfer_ != nullptr); + return value; +} +inline bool V1Frame::has_payload_transfer() const { + return _internal_has_payload_transfer(); +} +inline void V1Frame::clear_payload_transfer() { + if (payload_transfer_ != nullptr) payload_transfer_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::location::nearby::connections::PayloadTransferFrame& V1Frame::_internal_payload_transfer() const { + const ::location::nearby::connections::PayloadTransferFrame* p = payload_transfer_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_PayloadTransferFrame_default_instance_); +} +inline const ::location::nearby::connections::PayloadTransferFrame& V1Frame::payload_transfer() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.payload_transfer) + return _internal_payload_transfer(); +} +inline void V1Frame::unsafe_arena_set_allocated_payload_transfer( + ::location::nearby::connections::PayloadTransferFrame* payload_transfer) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(payload_transfer_); + } + payload_transfer_ = payload_transfer; + if (payload_transfer) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.payload_transfer) +} +inline ::location::nearby::connections::PayloadTransferFrame* V1Frame::release_payload_transfer() { + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::PayloadTransferFrame* temp = payload_transfer_; + payload_transfer_ = 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 ::location::nearby::connections::PayloadTransferFrame* V1Frame::unsafe_arena_release_payload_transfer() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.payload_transfer) + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::PayloadTransferFrame* temp = payload_transfer_; + payload_transfer_ = nullptr; + return temp; +} +inline ::location::nearby::connections::PayloadTransferFrame* V1Frame::_internal_mutable_payload_transfer() { + _has_bits_[0] |= 0x00000004u; + if (payload_transfer_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame>(GetArenaForAllocation()); + payload_transfer_ = p; + } + return payload_transfer_; +} +inline ::location::nearby::connections::PayloadTransferFrame* V1Frame::mutable_payload_transfer() { + ::location::nearby::connections::PayloadTransferFrame* _msg = _internal_mutable_payload_transfer(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.payload_transfer) + return _msg; +} +inline void V1Frame::set_allocated_payload_transfer(::location::nearby::connections::PayloadTransferFrame* payload_transfer) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete payload_transfer_; + } + if (payload_transfer) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::PayloadTransferFrame>::GetOwningArena(payload_transfer); + if (message_arena != submessage_arena) { + payload_transfer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, payload_transfer, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + payload_transfer_ = payload_transfer; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.payload_transfer) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame bandwidth_upgrade_negotiation = 5; +inline bool V1Frame::_internal_has_bandwidth_upgrade_negotiation() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || bandwidth_upgrade_negotiation_ != nullptr); + return value; +} +inline bool V1Frame::has_bandwidth_upgrade_negotiation() const { + return _internal_has_bandwidth_upgrade_negotiation(); +} +inline void V1Frame::clear_bandwidth_upgrade_negotiation() { + if (bandwidth_upgrade_negotiation_ != nullptr) bandwidth_upgrade_negotiation_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame& V1Frame::_internal_bandwidth_upgrade_negotiation() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* p = bandwidth_upgrade_negotiation_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame& V1Frame::bandwidth_upgrade_negotiation() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.bandwidth_upgrade_negotiation) + return _internal_bandwidth_upgrade_negotiation(); +} +inline void V1Frame::unsafe_arena_set_allocated_bandwidth_upgrade_negotiation( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* bandwidth_upgrade_negotiation) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bandwidth_upgrade_negotiation_); + } + bandwidth_upgrade_negotiation_ = bandwidth_upgrade_negotiation; + if (bandwidth_upgrade_negotiation) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.bandwidth_upgrade_negotiation) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* V1Frame::release_bandwidth_upgrade_negotiation() { + _has_bits_[0] &= ~0x00000008u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* temp = bandwidth_upgrade_negotiation_; + bandwidth_upgrade_negotiation_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* V1Frame::unsafe_arena_release_bandwidth_upgrade_negotiation() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.bandwidth_upgrade_negotiation) + _has_bits_[0] &= ~0x00000008u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* temp = bandwidth_upgrade_negotiation_; + bandwidth_upgrade_negotiation_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* V1Frame::_internal_mutable_bandwidth_upgrade_negotiation() { + _has_bits_[0] |= 0x00000008u; + if (bandwidth_upgrade_negotiation_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame>(GetArenaForAllocation()); + bandwidth_upgrade_negotiation_ = p; + } + return bandwidth_upgrade_negotiation_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* V1Frame::mutable_bandwidth_upgrade_negotiation() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* _msg = _internal_mutable_bandwidth_upgrade_negotiation(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.bandwidth_upgrade_negotiation) + return _msg; +} +inline void V1Frame::set_allocated_bandwidth_upgrade_negotiation(::location::nearby::connections::BandwidthUpgradeNegotiationFrame* bandwidth_upgrade_negotiation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bandwidth_upgrade_negotiation_; + } + if (bandwidth_upgrade_negotiation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame>::GetOwningArena(bandwidth_upgrade_negotiation); + if (message_arena != submessage_arena) { + bandwidth_upgrade_negotiation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bandwidth_upgrade_negotiation, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + bandwidth_upgrade_negotiation_ = bandwidth_upgrade_negotiation; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.bandwidth_upgrade_negotiation) +} + +// optional .location.nearby.connections.KeepAliveFrame keep_alive = 6; +inline bool V1Frame::_internal_has_keep_alive() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || keep_alive_ != nullptr); + return value; +} +inline bool V1Frame::has_keep_alive() const { + return _internal_has_keep_alive(); +} +inline void V1Frame::clear_keep_alive() { + if (keep_alive_ != nullptr) keep_alive_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::location::nearby::connections::KeepAliveFrame& V1Frame::_internal_keep_alive() const { + const ::location::nearby::connections::KeepAliveFrame* p = keep_alive_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_KeepAliveFrame_default_instance_); +} +inline const ::location::nearby::connections::KeepAliveFrame& V1Frame::keep_alive() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.keep_alive) + return _internal_keep_alive(); +} +inline void V1Frame::unsafe_arena_set_allocated_keep_alive( + ::location::nearby::connections::KeepAliveFrame* keep_alive) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(keep_alive_); + } + keep_alive_ = keep_alive; + if (keep_alive) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.keep_alive) +} +inline ::location::nearby::connections::KeepAliveFrame* V1Frame::release_keep_alive() { + _has_bits_[0] &= ~0x00000010u; + ::location::nearby::connections::KeepAliveFrame* temp = keep_alive_; + keep_alive_ = 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 ::location::nearby::connections::KeepAliveFrame* V1Frame::unsafe_arena_release_keep_alive() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.keep_alive) + _has_bits_[0] &= ~0x00000010u; + ::location::nearby::connections::KeepAliveFrame* temp = keep_alive_; + keep_alive_ = nullptr; + return temp; +} +inline ::location::nearby::connections::KeepAliveFrame* V1Frame::_internal_mutable_keep_alive() { + _has_bits_[0] |= 0x00000010u; + if (keep_alive_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::KeepAliveFrame>(GetArenaForAllocation()); + keep_alive_ = p; + } + return keep_alive_; +} +inline ::location::nearby::connections::KeepAliveFrame* V1Frame::mutable_keep_alive() { + ::location::nearby::connections::KeepAliveFrame* _msg = _internal_mutable_keep_alive(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.keep_alive) + return _msg; +} +inline void V1Frame::set_allocated_keep_alive(::location::nearby::connections::KeepAliveFrame* keep_alive) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete keep_alive_; + } + if (keep_alive) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::KeepAliveFrame>::GetOwningArena(keep_alive); + if (message_arena != submessage_arena) { + keep_alive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, keep_alive, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + keep_alive_ = keep_alive; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.keep_alive) +} + +// optional .location.nearby.connections.DisconnectionFrame disconnection = 7; +inline bool V1Frame::_internal_has_disconnection() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || disconnection_ != nullptr); + return value; +} +inline bool V1Frame::has_disconnection() const { + return _internal_has_disconnection(); +} +inline void V1Frame::clear_disconnection() { + if (disconnection_ != nullptr) disconnection_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::location::nearby::connections::DisconnectionFrame& V1Frame::_internal_disconnection() const { + const ::location::nearby::connections::DisconnectionFrame* p = disconnection_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_DisconnectionFrame_default_instance_); +} +inline const ::location::nearby::connections::DisconnectionFrame& V1Frame::disconnection() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.disconnection) + return _internal_disconnection(); +} +inline void V1Frame::unsafe_arena_set_allocated_disconnection( + ::location::nearby::connections::DisconnectionFrame* disconnection) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(disconnection_); + } + disconnection_ = disconnection; + if (disconnection) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.disconnection) +} +inline ::location::nearby::connections::DisconnectionFrame* V1Frame::release_disconnection() { + _has_bits_[0] &= ~0x00000020u; + ::location::nearby::connections::DisconnectionFrame* temp = disconnection_; + disconnection_ = 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 ::location::nearby::connections::DisconnectionFrame* V1Frame::unsafe_arena_release_disconnection() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.disconnection) + _has_bits_[0] &= ~0x00000020u; + ::location::nearby::connections::DisconnectionFrame* temp = disconnection_; + disconnection_ = nullptr; + return temp; +} +inline ::location::nearby::connections::DisconnectionFrame* V1Frame::_internal_mutable_disconnection() { + _has_bits_[0] |= 0x00000020u; + if (disconnection_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::DisconnectionFrame>(GetArenaForAllocation()); + disconnection_ = p; + } + return disconnection_; +} +inline ::location::nearby::connections::DisconnectionFrame* V1Frame::mutable_disconnection() { + ::location::nearby::connections::DisconnectionFrame* _msg = _internal_mutable_disconnection(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.disconnection) + return _msg; +} +inline void V1Frame::set_allocated_disconnection(::location::nearby::connections::DisconnectionFrame* disconnection) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete disconnection_; + } + if (disconnection) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::DisconnectionFrame>::GetOwningArena(disconnection); + if (message_arena != submessage_arena) { + disconnection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, disconnection, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + disconnection_ = disconnection; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.disconnection) +} + +// optional .location.nearby.connections.PairedKeyEncryptionFrame paired_key_encryption = 8; +inline bool V1Frame::_internal_has_paired_key_encryption() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || paired_key_encryption_ != nullptr); + return value; +} +inline bool V1Frame::has_paired_key_encryption() const { + return _internal_has_paired_key_encryption(); +} +inline void V1Frame::clear_paired_key_encryption() { + if (paired_key_encryption_ != nullptr) paired_key_encryption_->Clear(); + _has_bits_[0] &= ~0x00000040u; +} +inline const ::location::nearby::connections::PairedKeyEncryptionFrame& V1Frame::_internal_paired_key_encryption() const { + const ::location::nearby::connections::PairedKeyEncryptionFrame* p = paired_key_encryption_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_PairedKeyEncryptionFrame_default_instance_); +} +inline const ::location::nearby::connections::PairedKeyEncryptionFrame& V1Frame::paired_key_encryption() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.paired_key_encryption) + return _internal_paired_key_encryption(); +} +inline void V1Frame::unsafe_arena_set_allocated_paired_key_encryption( + ::location::nearby::connections::PairedKeyEncryptionFrame* paired_key_encryption) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(paired_key_encryption_); + } + paired_key_encryption_ = paired_key_encryption; + if (paired_key_encryption) { + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.paired_key_encryption) +} +inline ::location::nearby::connections::PairedKeyEncryptionFrame* V1Frame::release_paired_key_encryption() { + _has_bits_[0] &= ~0x00000040u; + ::location::nearby::connections::PairedKeyEncryptionFrame* temp = paired_key_encryption_; + paired_key_encryption_ = 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 ::location::nearby::connections::PairedKeyEncryptionFrame* V1Frame::unsafe_arena_release_paired_key_encryption() { + // @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.paired_key_encryption) + _has_bits_[0] &= ~0x00000040u; + ::location::nearby::connections::PairedKeyEncryptionFrame* temp = paired_key_encryption_; + paired_key_encryption_ = nullptr; + return temp; +} +inline ::location::nearby::connections::PairedKeyEncryptionFrame* V1Frame::_internal_mutable_paired_key_encryption() { + _has_bits_[0] |= 0x00000040u; + if (paired_key_encryption_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::PairedKeyEncryptionFrame>(GetArenaForAllocation()); + paired_key_encryption_ = p; + } + return paired_key_encryption_; +} +inline ::location::nearby::connections::PairedKeyEncryptionFrame* V1Frame::mutable_paired_key_encryption() { + ::location::nearby::connections::PairedKeyEncryptionFrame* _msg = _internal_mutable_paired_key_encryption(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.paired_key_encryption) + return _msg; +} +inline void V1Frame::set_allocated_paired_key_encryption(::location::nearby::connections::PairedKeyEncryptionFrame* paired_key_encryption) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete paired_key_encryption_; + } + if (paired_key_encryption) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::PairedKeyEncryptionFrame>::GetOwningArena(paired_key_encryption); + if (message_arena != submessage_arena) { + paired_key_encryption = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, paired_key_encryption, submessage_arena); + } + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + paired_key_encryption_ = paired_key_encryption; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.paired_key_encryption) +} + +// ------------------------------------------------------------------- + +// ConnectionRequestFrame + +// optional string endpoint_id = 1; +inline bool ConnectionRequestFrame::_internal_has_endpoint_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ConnectionRequestFrame::has_endpoint_id() const { + return _internal_has_endpoint_id(); +} +inline void ConnectionRequestFrame::clear_endpoint_id() { + endpoint_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ConnectionRequestFrame::endpoint_id() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.endpoint_id) + return _internal_endpoint_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ConnectionRequestFrame::set_endpoint_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.endpoint_id) +} +inline std::string* ConnectionRequestFrame::mutable_endpoint_id() { + std::string* _s = _internal_mutable_endpoint_id(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.ConnectionRequestFrame.endpoint_id) + return _s; +} +inline const std::string& ConnectionRequestFrame::_internal_endpoint_id() const { + return endpoint_id_.Get(); +} +inline void ConnectionRequestFrame::_internal_set_endpoint_id(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::_internal_mutable_endpoint_id() { + _has_bits_[0] |= 0x00000001u; + return endpoint_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::release_endpoint_id() { + // @@protoc_insertion_point(field_release:location.nearby.connections.ConnectionRequestFrame.endpoint_id) + if (!_internal_has_endpoint_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = endpoint_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ConnectionRequestFrame::set_allocated_endpoint_id(std::string* endpoint_id) { + if (endpoint_id != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + endpoint_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), endpoint_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.ConnectionRequestFrame.endpoint_id) +} + +// optional string endpoint_name = 2; +inline bool ConnectionRequestFrame::_internal_has_endpoint_name() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ConnectionRequestFrame::has_endpoint_name() const { + return _internal_has_endpoint_name(); +} +inline void ConnectionRequestFrame::clear_endpoint_name() { + endpoint_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& ConnectionRequestFrame::endpoint_name() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.endpoint_name) + return _internal_endpoint_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ConnectionRequestFrame::set_endpoint_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + endpoint_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.endpoint_name) +} +inline std::string* ConnectionRequestFrame::mutable_endpoint_name() { + std::string* _s = _internal_mutable_endpoint_name(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.ConnectionRequestFrame.endpoint_name) + return _s; +} +inline const std::string& ConnectionRequestFrame::_internal_endpoint_name() const { + return endpoint_name_.Get(); +} +inline void ConnectionRequestFrame::_internal_set_endpoint_name(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + endpoint_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::_internal_mutable_endpoint_name() { + _has_bits_[0] |= 0x00000002u; + return endpoint_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::release_endpoint_name() { + // @@protoc_insertion_point(field_release:location.nearby.connections.ConnectionRequestFrame.endpoint_name) + if (!_internal_has_endpoint_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = endpoint_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ConnectionRequestFrame::set_allocated_endpoint_name(std::string* endpoint_name) { + if (endpoint_name != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + endpoint_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), endpoint_name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.ConnectionRequestFrame.endpoint_name) +} + +// optional bytes handshake_data = 3; +inline bool ConnectionRequestFrame::_internal_has_handshake_data() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ConnectionRequestFrame::has_handshake_data() const { + return _internal_has_handshake_data(); +} +inline void ConnectionRequestFrame::clear_handshake_data() { + handshake_data_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& ConnectionRequestFrame::handshake_data() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.handshake_data) + return _internal_handshake_data(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ConnectionRequestFrame::set_handshake_data(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + handshake_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.handshake_data) +} +inline std::string* ConnectionRequestFrame::mutable_handshake_data() { + std::string* _s = _internal_mutable_handshake_data(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.ConnectionRequestFrame.handshake_data) + return _s; +} +inline const std::string& ConnectionRequestFrame::_internal_handshake_data() const { + return handshake_data_.Get(); +} +inline void ConnectionRequestFrame::_internal_set_handshake_data(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + handshake_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::_internal_mutable_handshake_data() { + _has_bits_[0] |= 0x00000004u; + return handshake_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::release_handshake_data() { + // @@protoc_insertion_point(field_release:location.nearby.connections.ConnectionRequestFrame.handshake_data) + if (!_internal_has_handshake_data()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = handshake_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (handshake_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + handshake_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ConnectionRequestFrame::set_allocated_handshake_data(std::string* handshake_data) { + if (handshake_data != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + handshake_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), handshake_data, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (handshake_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + handshake_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.ConnectionRequestFrame.handshake_data) +} + +// optional int32 nonce = 4; +inline bool ConnectionRequestFrame::_internal_has_nonce() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ConnectionRequestFrame::has_nonce() const { + return _internal_has_nonce(); +} +inline void ConnectionRequestFrame::clear_nonce() { + nonce_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline int32_t ConnectionRequestFrame::_internal_nonce() const { + return nonce_; +} +inline int32_t ConnectionRequestFrame::nonce() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.nonce) + return _internal_nonce(); +} +inline void ConnectionRequestFrame::_internal_set_nonce(int32_t value) { + _has_bits_[0] |= 0x00000040u; + nonce_ = value; +} +inline void ConnectionRequestFrame::set_nonce(int32_t value) { + _internal_set_nonce(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.nonce) +} + +// repeated .location.nearby.connections.ConnectionRequestFrame.Medium mediums = 5; +inline int ConnectionRequestFrame::_internal_mediums_size() const { + return mediums_.size(); +} +inline int ConnectionRequestFrame::mediums_size() const { + return _internal_mediums_size(); +} +inline void ConnectionRequestFrame::clear_mediums() { + mediums_.Clear(); +} +inline ::location::nearby::connections::ConnectionRequestFrame_Medium ConnectionRequestFrame::_internal_mediums(int index) const { + return static_cast< ::location::nearby::connections::ConnectionRequestFrame_Medium >(mediums_.Get(index)); +} +inline ::location::nearby::connections::ConnectionRequestFrame_Medium ConnectionRequestFrame::mediums(int index) const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.mediums) + return _internal_mediums(index); +} +inline void ConnectionRequestFrame::set_mediums(int index, ::location::nearby::connections::ConnectionRequestFrame_Medium value) { + assert(::location::nearby::connections::ConnectionRequestFrame_Medium_IsValid(value)); + mediums_.Set(index, value); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.mediums) +} +inline void ConnectionRequestFrame::_internal_add_mediums(::location::nearby::connections::ConnectionRequestFrame_Medium value) { + assert(::location::nearby::connections::ConnectionRequestFrame_Medium_IsValid(value)); + mediums_.Add(value); +} +inline void ConnectionRequestFrame::add_mediums(::location::nearby::connections::ConnectionRequestFrame_Medium value) { + _internal_add_mediums(value); + // @@protoc_insertion_point(field_add:location.nearby.connections.ConnectionRequestFrame.mediums) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& +ConnectionRequestFrame::mediums() const { + // @@protoc_insertion_point(field_list:location.nearby.connections.ConnectionRequestFrame.mediums) + return mediums_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +ConnectionRequestFrame::_internal_mutable_mediums() { + return &mediums_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +ConnectionRequestFrame::mutable_mediums() { + // @@protoc_insertion_point(field_mutable_list:location.nearby.connections.ConnectionRequestFrame.mediums) + return _internal_mutable_mediums(); +} + +// optional bytes endpoint_info = 6; +inline bool ConnectionRequestFrame::_internal_has_endpoint_info() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ConnectionRequestFrame::has_endpoint_info() const { + return _internal_has_endpoint_info(); +} +inline void ConnectionRequestFrame::clear_endpoint_info() { + endpoint_info_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& ConnectionRequestFrame::endpoint_info() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.endpoint_info) + return _internal_endpoint_info(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ConnectionRequestFrame::set_endpoint_info(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000008u; + endpoint_info_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.endpoint_info) +} +inline std::string* ConnectionRequestFrame::mutable_endpoint_info() { + std::string* _s = _internal_mutable_endpoint_info(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.ConnectionRequestFrame.endpoint_info) + return _s; +} +inline const std::string& ConnectionRequestFrame::_internal_endpoint_info() const { + return endpoint_info_.Get(); +} +inline void ConnectionRequestFrame::_internal_set_endpoint_info(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + endpoint_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::_internal_mutable_endpoint_info() { + _has_bits_[0] |= 0x00000008u; + return endpoint_info_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::release_endpoint_info() { + // @@protoc_insertion_point(field_release:location.nearby.connections.ConnectionRequestFrame.endpoint_info) + if (!_internal_has_endpoint_info()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto* p = endpoint_info_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_info_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ConnectionRequestFrame::set_allocated_endpoint_info(std::string* endpoint_info) { + if (endpoint_info != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + endpoint_info_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), endpoint_info, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_info_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.ConnectionRequestFrame.endpoint_info) +} + +// optional .location.nearby.connections.MediumMetadata medium_metadata = 7; +inline bool ConnectionRequestFrame::_internal_has_medium_metadata() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || medium_metadata_ != nullptr); + return value; +} +inline bool ConnectionRequestFrame::has_medium_metadata() const { + return _internal_has_medium_metadata(); +} +inline void ConnectionRequestFrame::clear_medium_metadata() { + if (medium_metadata_ != nullptr) medium_metadata_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::location::nearby::connections::MediumMetadata& ConnectionRequestFrame::_internal_medium_metadata() const { + const ::location::nearby::connections::MediumMetadata* p = medium_metadata_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_MediumMetadata_default_instance_); +} +inline const ::location::nearby::connections::MediumMetadata& ConnectionRequestFrame::medium_metadata() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.medium_metadata) + return _internal_medium_metadata(); +} +inline void ConnectionRequestFrame::unsafe_arena_set_allocated_medium_metadata( + ::location::nearby::connections::MediumMetadata* medium_metadata) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(medium_metadata_); + } + medium_metadata_ = medium_metadata; + if (medium_metadata) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.ConnectionRequestFrame.medium_metadata) +} +inline ::location::nearby::connections::MediumMetadata* ConnectionRequestFrame::release_medium_metadata() { + _has_bits_[0] &= ~0x00000020u; + ::location::nearby::connections::MediumMetadata* temp = medium_metadata_; + medium_metadata_ = 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 ::location::nearby::connections::MediumMetadata* ConnectionRequestFrame::unsafe_arena_release_medium_metadata() { + // @@protoc_insertion_point(field_release:location.nearby.connections.ConnectionRequestFrame.medium_metadata) + _has_bits_[0] &= ~0x00000020u; + ::location::nearby::connections::MediumMetadata* temp = medium_metadata_; + medium_metadata_ = nullptr; + return temp; +} +inline ::location::nearby::connections::MediumMetadata* ConnectionRequestFrame::_internal_mutable_medium_metadata() { + _has_bits_[0] |= 0x00000020u; + if (medium_metadata_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::MediumMetadata>(GetArenaForAllocation()); + medium_metadata_ = p; + } + return medium_metadata_; +} +inline ::location::nearby::connections::MediumMetadata* ConnectionRequestFrame::mutable_medium_metadata() { + ::location::nearby::connections::MediumMetadata* _msg = _internal_mutable_medium_metadata(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.ConnectionRequestFrame.medium_metadata) + return _msg; +} +inline void ConnectionRequestFrame::set_allocated_medium_metadata(::location::nearby::connections::MediumMetadata* medium_metadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete medium_metadata_; + } + if (medium_metadata) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::MediumMetadata>::GetOwningArena(medium_metadata); + if (message_arena != submessage_arena) { + medium_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, medium_metadata, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + medium_metadata_ = medium_metadata; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.ConnectionRequestFrame.medium_metadata) +} + +// optional int32 keep_alive_interval_millis = 8; +inline bool ConnectionRequestFrame::_internal_has_keep_alive_interval_millis() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool ConnectionRequestFrame::has_keep_alive_interval_millis() const { + return _internal_has_keep_alive_interval_millis(); +} +inline void ConnectionRequestFrame::clear_keep_alive_interval_millis() { + keep_alive_interval_millis_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline int32_t ConnectionRequestFrame::_internal_keep_alive_interval_millis() const { + return keep_alive_interval_millis_; +} +inline int32_t ConnectionRequestFrame::keep_alive_interval_millis() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.keep_alive_interval_millis) + return _internal_keep_alive_interval_millis(); +} +inline void ConnectionRequestFrame::_internal_set_keep_alive_interval_millis(int32_t value) { + _has_bits_[0] |= 0x00000080u; + keep_alive_interval_millis_ = value; +} +inline void ConnectionRequestFrame::set_keep_alive_interval_millis(int32_t value) { + _internal_set_keep_alive_interval_millis(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.keep_alive_interval_millis) +} + +// optional int32 keep_alive_timeout_millis = 9; +inline bool ConnectionRequestFrame::_internal_has_keep_alive_timeout_millis() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool ConnectionRequestFrame::has_keep_alive_timeout_millis() const { + return _internal_has_keep_alive_timeout_millis(); +} +inline void ConnectionRequestFrame::clear_keep_alive_timeout_millis() { + keep_alive_timeout_millis_ = 0; + _has_bits_[0] &= ~0x00000100u; +} +inline int32_t ConnectionRequestFrame::_internal_keep_alive_timeout_millis() const { + return keep_alive_timeout_millis_; +} +inline int32_t ConnectionRequestFrame::keep_alive_timeout_millis() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.keep_alive_timeout_millis) + return _internal_keep_alive_timeout_millis(); +} +inline void ConnectionRequestFrame::_internal_set_keep_alive_timeout_millis(int32_t value) { + _has_bits_[0] |= 0x00000100u; + keep_alive_timeout_millis_ = value; +} +inline void ConnectionRequestFrame::set_keep_alive_timeout_millis(int32_t value) { + _internal_set_keep_alive_timeout_millis(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.keep_alive_timeout_millis) +} + +// optional int32 device_type = 10 [default = 0]; +inline bool ConnectionRequestFrame::_internal_has_device_type() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool ConnectionRequestFrame::has_device_type() const { + return _internal_has_device_type(); +} +inline void ConnectionRequestFrame::clear_device_type() { + device_type_ = 0; + _has_bits_[0] &= ~0x00000200u; +} +inline int32_t ConnectionRequestFrame::_internal_device_type() const { + return device_type_; +} +inline int32_t ConnectionRequestFrame::device_type() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.device_type) + return _internal_device_type(); +} +inline void ConnectionRequestFrame::_internal_set_device_type(int32_t value) { + _has_bits_[0] |= 0x00000200u; + device_type_ = value; +} +inline void ConnectionRequestFrame::set_device_type(int32_t value) { + _internal_set_device_type(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.device_type) +} + +// optional bytes device_info = 11; +inline bool ConnectionRequestFrame::_internal_has_device_info() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ConnectionRequestFrame::has_device_info() const { + return _internal_has_device_info(); +} +inline void ConnectionRequestFrame::clear_device_info() { + device_info_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string& ConnectionRequestFrame::device_info() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionRequestFrame.device_info) + return _internal_device_info(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ConnectionRequestFrame::set_device_info(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000010u; + device_info_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionRequestFrame.device_info) +} +inline std::string* ConnectionRequestFrame::mutable_device_info() { + std::string* _s = _internal_mutable_device_info(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.ConnectionRequestFrame.device_info) + return _s; +} +inline const std::string& ConnectionRequestFrame::_internal_device_info() const { + return device_info_.Get(); +} +inline void ConnectionRequestFrame::_internal_set_device_info(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + device_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::_internal_mutable_device_info() { + _has_bits_[0] |= 0x00000010u; + return device_info_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ConnectionRequestFrame::release_device_info() { + // @@protoc_insertion_point(field_release:location.nearby.connections.ConnectionRequestFrame.device_info) + if (!_internal_has_device_info()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + auto* p = device_info_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (device_info_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + device_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ConnectionRequestFrame::set_allocated_device_info(std::string* device_info) { + if (device_info != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + device_info_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_info, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (device_info_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + device_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.ConnectionRequestFrame.device_info) +} + +// ------------------------------------------------------------------- + +// ConnectionResponseFrame + +// optional int32 status = 1 [deprecated = true]; +inline bool ConnectionResponseFrame::_internal_has_status() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ConnectionResponseFrame::has_status() const { + return _internal_has_status(); +} +inline void ConnectionResponseFrame::clear_status() { + status_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t ConnectionResponseFrame::_internal_status() const { + return status_; +} +inline int32_t ConnectionResponseFrame::status() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionResponseFrame.status) + return _internal_status(); +} +inline void ConnectionResponseFrame::_internal_set_status(int32_t value) { + _has_bits_[0] |= 0x00000002u; + status_ = value; +} +inline void ConnectionResponseFrame::set_status(int32_t value) { + _internal_set_status(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionResponseFrame.status) +} + +// optional bytes handshake_data = 2; +inline bool ConnectionResponseFrame::_internal_has_handshake_data() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ConnectionResponseFrame::has_handshake_data() const { + return _internal_has_handshake_data(); +} +inline void ConnectionResponseFrame::clear_handshake_data() { + handshake_data_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& ConnectionResponseFrame::handshake_data() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionResponseFrame.handshake_data) + return _internal_handshake_data(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void ConnectionResponseFrame::set_handshake_data(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + handshake_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionResponseFrame.handshake_data) +} +inline std::string* ConnectionResponseFrame::mutable_handshake_data() { + std::string* _s = _internal_mutable_handshake_data(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.ConnectionResponseFrame.handshake_data) + return _s; +} +inline const std::string& ConnectionResponseFrame::_internal_handshake_data() const { + return handshake_data_.Get(); +} +inline void ConnectionResponseFrame::_internal_set_handshake_data(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + handshake_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* ConnectionResponseFrame::_internal_mutable_handshake_data() { + _has_bits_[0] |= 0x00000001u; + return handshake_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* ConnectionResponseFrame::release_handshake_data() { + // @@protoc_insertion_point(field_release:location.nearby.connections.ConnectionResponseFrame.handshake_data) + if (!_internal_has_handshake_data()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = handshake_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (handshake_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + handshake_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ConnectionResponseFrame::set_allocated_handshake_data(std::string* handshake_data) { + if (handshake_data != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + handshake_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), handshake_data, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (handshake_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + handshake_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.ConnectionResponseFrame.handshake_data) +} + +// optional .location.nearby.connections.ConnectionResponseFrame.ResponseStatus response = 3; +inline bool ConnectionResponseFrame::_internal_has_response() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ConnectionResponseFrame::has_response() const { + return _internal_has_response(); +} +inline void ConnectionResponseFrame::clear_response() { + response_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline ::location::nearby::connections::ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame::_internal_response() const { + return static_cast< ::location::nearby::connections::ConnectionResponseFrame_ResponseStatus >(response_); +} +inline ::location::nearby::connections::ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame::response() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionResponseFrame.response) + return _internal_response(); +} +inline void ConnectionResponseFrame::_internal_set_response(::location::nearby::connections::ConnectionResponseFrame_ResponseStatus value) { + assert(::location::nearby::connections::ConnectionResponseFrame_ResponseStatus_IsValid(value)); + _has_bits_[0] |= 0x00000004u; + response_ = value; +} +inline void ConnectionResponseFrame::set_response(::location::nearby::connections::ConnectionResponseFrame_ResponseStatus value) { + _internal_set_response(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionResponseFrame.response) +} + +// ------------------------------------------------------------------- + +// PayloadTransferFrame_PayloadHeader + +// optional int64 id = 1; +inline bool PayloadTransferFrame_PayloadHeader::_internal_has_id() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadHeader::has_id() const { + return _internal_has_id(); +} +inline void PayloadTransferFrame_PayloadHeader::clear_id() { + id_ = int64_t{0}; + _has_bits_[0] &= ~0x00000004u; +} +inline int64_t PayloadTransferFrame_PayloadHeader::_internal_id() const { + return id_; +} +inline int64_t PayloadTransferFrame_PayloadHeader::id() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadHeader.id) + return _internal_id(); +} +inline void PayloadTransferFrame_PayloadHeader::_internal_set_id(int64_t value) { + _has_bits_[0] |= 0x00000004u; + id_ = value; +} +inline void PayloadTransferFrame_PayloadHeader::set_id(int64_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadHeader.id) +} + +// optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader.PayloadType type = 2; +inline bool PayloadTransferFrame_PayloadHeader::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadHeader::has_type() const { + return _internal_has_type(); +} +inline void PayloadTransferFrame_PayloadHeader::clear_type() { + type_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline ::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader::_internal_type() const { + return static_cast< ::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType >(type_); +} +inline ::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType PayloadTransferFrame_PayloadHeader::type() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadHeader.type) + return _internal_type(); +} +inline void PayloadTransferFrame_PayloadHeader::_internal_set_type(::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType value) { + assert(::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType_IsValid(value)); + _has_bits_[0] |= 0x00000010u; + type_ = value; +} +inline void PayloadTransferFrame_PayloadHeader::set_type(::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadHeader.type) +} + +// optional int64 total_size = 3; +inline bool PayloadTransferFrame_PayloadHeader::_internal_has_total_size() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadHeader::has_total_size() const { + return _internal_has_total_size(); +} +inline void PayloadTransferFrame_PayloadHeader::clear_total_size() { + total_size_ = int64_t{0}; + _has_bits_[0] &= ~0x00000008u; +} +inline int64_t PayloadTransferFrame_PayloadHeader::_internal_total_size() const { + return total_size_; +} +inline int64_t PayloadTransferFrame_PayloadHeader::total_size() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadHeader.total_size) + return _internal_total_size(); +} +inline void PayloadTransferFrame_PayloadHeader::_internal_set_total_size(int64_t value) { + _has_bits_[0] |= 0x00000008u; + total_size_ = value; +} +inline void PayloadTransferFrame_PayloadHeader::set_total_size(int64_t value) { + _internal_set_total_size(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadHeader.total_size) +} + +// optional bool is_sensitive = 4; +inline bool PayloadTransferFrame_PayloadHeader::_internal_has_is_sensitive() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadHeader::has_is_sensitive() const { + return _internal_has_is_sensitive(); +} +inline void PayloadTransferFrame_PayloadHeader::clear_is_sensitive() { + is_sensitive_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool PayloadTransferFrame_PayloadHeader::_internal_is_sensitive() const { + return is_sensitive_; +} +inline bool PayloadTransferFrame_PayloadHeader::is_sensitive() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadHeader.is_sensitive) + return _internal_is_sensitive(); +} +inline void PayloadTransferFrame_PayloadHeader::_internal_set_is_sensitive(bool value) { + _has_bits_[0] |= 0x00000020u; + is_sensitive_ = value; +} +inline void PayloadTransferFrame_PayloadHeader::set_is_sensitive(bool value) { + _internal_set_is_sensitive(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadHeader.is_sensitive) +} + +// optional string file_name = 5; +inline bool PayloadTransferFrame_PayloadHeader::_internal_has_file_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadHeader::has_file_name() const { + return _internal_has_file_name(); +} +inline void PayloadTransferFrame_PayloadHeader::clear_file_name() { + file_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PayloadTransferFrame_PayloadHeader::file_name() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadHeader.file_name) + return _internal_file_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PayloadTransferFrame_PayloadHeader::set_file_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadHeader.file_name) +} +inline std::string* PayloadTransferFrame_PayloadHeader::mutable_file_name() { + std::string* _s = _internal_mutable_file_name(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.PayloadTransferFrame.PayloadHeader.file_name) + return _s; +} +inline const std::string& PayloadTransferFrame_PayloadHeader::_internal_file_name() const { + return file_name_.Get(); +} +inline void PayloadTransferFrame_PayloadHeader::_internal_set_file_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* PayloadTransferFrame_PayloadHeader::_internal_mutable_file_name() { + _has_bits_[0] |= 0x00000001u; + return file_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* PayloadTransferFrame_PayloadHeader::release_file_name() { + // @@protoc_insertion_point(field_release:location.nearby.connections.PayloadTransferFrame.PayloadHeader.file_name) + if (!_internal_has_file_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = file_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (file_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PayloadTransferFrame_PayloadHeader::set_allocated_file_name(std::string* file_name) { + if (file_name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + file_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (file_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + file_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.PayloadTransferFrame.PayloadHeader.file_name) +} + +// optional string parent_folder = 6; +inline bool PayloadTransferFrame_PayloadHeader::_internal_has_parent_folder() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadHeader::has_parent_folder() const { + return _internal_has_parent_folder(); +} +inline void PayloadTransferFrame_PayloadHeader::clear_parent_folder() { + parent_folder_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& PayloadTransferFrame_PayloadHeader::parent_folder() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadHeader.parent_folder) + return _internal_parent_folder(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PayloadTransferFrame_PayloadHeader::set_parent_folder(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + parent_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadHeader.parent_folder) +} +inline std::string* PayloadTransferFrame_PayloadHeader::mutable_parent_folder() { + std::string* _s = _internal_mutable_parent_folder(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.PayloadTransferFrame.PayloadHeader.parent_folder) + return _s; +} +inline const std::string& PayloadTransferFrame_PayloadHeader::_internal_parent_folder() const { + return parent_folder_.Get(); +} +inline void PayloadTransferFrame_PayloadHeader::_internal_set_parent_folder(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + parent_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* PayloadTransferFrame_PayloadHeader::_internal_mutable_parent_folder() { + _has_bits_[0] |= 0x00000002u; + return parent_folder_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* PayloadTransferFrame_PayloadHeader::release_parent_folder() { + // @@protoc_insertion_point(field_release:location.nearby.connections.PayloadTransferFrame.PayloadHeader.parent_folder) + if (!_internal_has_parent_folder()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = parent_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (parent_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + parent_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PayloadTransferFrame_PayloadHeader::set_allocated_parent_folder(std::string* parent_folder) { + if (parent_folder != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + parent_folder_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), parent_folder, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (parent_folder_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + parent_folder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.PayloadTransferFrame.PayloadHeader.parent_folder) +} + +// ------------------------------------------------------------------- + +// PayloadTransferFrame_PayloadChunk + +// optional int32 flags = 1; +inline bool PayloadTransferFrame_PayloadChunk::_internal_has_flags() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadChunk::has_flags() const { + return _internal_has_flags(); +} +inline void PayloadTransferFrame_PayloadChunk::clear_flags() { + flags_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t PayloadTransferFrame_PayloadChunk::_internal_flags() const { + return flags_; +} +inline int32_t PayloadTransferFrame_PayloadChunk::flags() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadChunk.flags) + return _internal_flags(); +} +inline void PayloadTransferFrame_PayloadChunk::_internal_set_flags(int32_t value) { + _has_bits_[0] |= 0x00000004u; + flags_ = value; +} +inline void PayloadTransferFrame_PayloadChunk::set_flags(int32_t value) { + _internal_set_flags(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadChunk.flags) +} + +// optional int64 offset = 2; +inline bool PayloadTransferFrame_PayloadChunk::_internal_has_offset() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadChunk::has_offset() const { + return _internal_has_offset(); +} +inline void PayloadTransferFrame_PayloadChunk::clear_offset() { + offset_ = int64_t{0}; + _has_bits_[0] &= ~0x00000002u; +} +inline int64_t PayloadTransferFrame_PayloadChunk::_internal_offset() const { + return offset_; +} +inline int64_t PayloadTransferFrame_PayloadChunk::offset() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadChunk.offset) + return _internal_offset(); +} +inline void PayloadTransferFrame_PayloadChunk::_internal_set_offset(int64_t value) { + _has_bits_[0] |= 0x00000002u; + offset_ = value; +} +inline void PayloadTransferFrame_PayloadChunk::set_offset(int64_t value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadChunk.offset) +} + +// optional bytes body = 3; +inline bool PayloadTransferFrame_PayloadChunk::_internal_has_body() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PayloadTransferFrame_PayloadChunk::has_body() const { + return _internal_has_body(); +} +inline void PayloadTransferFrame_PayloadChunk::clear_body() { + body_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PayloadTransferFrame_PayloadChunk::body() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.PayloadChunk.body) + return _internal_body(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PayloadTransferFrame_PayloadChunk::set_body(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + body_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.PayloadChunk.body) +} +inline std::string* PayloadTransferFrame_PayloadChunk::mutable_body() { + std::string* _s = _internal_mutable_body(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.PayloadTransferFrame.PayloadChunk.body) + return _s; +} +inline const std::string& PayloadTransferFrame_PayloadChunk::_internal_body() const { + return body_.Get(); +} +inline void PayloadTransferFrame_PayloadChunk::_internal_set_body(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* PayloadTransferFrame_PayloadChunk::_internal_mutable_body() { + _has_bits_[0] |= 0x00000001u; + return body_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* PayloadTransferFrame_PayloadChunk::release_body() { + // @@protoc_insertion_point(field_release:location.nearby.connections.PayloadTransferFrame.PayloadChunk.body) + if (!_internal_has_body()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = body_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (body_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PayloadTransferFrame_PayloadChunk::set_allocated_body(std::string* body) { + if (body != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + body_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), body, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (body_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.PayloadTransferFrame.PayloadChunk.body) +} + +// ------------------------------------------------------------------- + +// PayloadTransferFrame_ControlMessage + +// optional .location.nearby.connections.PayloadTransferFrame.ControlMessage.EventType event = 1; +inline bool PayloadTransferFrame_ControlMessage::_internal_has_event() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool PayloadTransferFrame_ControlMessage::has_event() const { + return _internal_has_event(); +} +inline void PayloadTransferFrame_ControlMessage::clear_event() { + event_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage::_internal_event() const { + return static_cast< ::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType >(event_); +} +inline ::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage::event() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.ControlMessage.event) + return _internal_event(); +} +inline void PayloadTransferFrame_ControlMessage::_internal_set_event(::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType value) { + assert(::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + event_ = value; +} +inline void PayloadTransferFrame_ControlMessage::set_event(::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType value) { + _internal_set_event(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.ControlMessage.event) +} + +// optional int64 offset = 2; +inline bool PayloadTransferFrame_ControlMessage::_internal_has_offset() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PayloadTransferFrame_ControlMessage::has_offset() const { + return _internal_has_offset(); +} +inline void PayloadTransferFrame_ControlMessage::clear_offset() { + offset_ = int64_t{0}; + _has_bits_[0] &= ~0x00000001u; +} +inline int64_t PayloadTransferFrame_ControlMessage::_internal_offset() const { + return offset_; +} +inline int64_t PayloadTransferFrame_ControlMessage::offset() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.ControlMessage.offset) + return _internal_offset(); +} +inline void PayloadTransferFrame_ControlMessage::_internal_set_offset(int64_t value) { + _has_bits_[0] |= 0x00000001u; + offset_ = value; +} +inline void PayloadTransferFrame_ControlMessage::set_offset(int64_t value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.ControlMessage.offset) +} + +// ------------------------------------------------------------------- + +// PayloadTransferFrame + +// optional .location.nearby.connections.PayloadTransferFrame.PacketType packet_type = 1; +inline bool PayloadTransferFrame::_internal_has_packet_type() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool PayloadTransferFrame::has_packet_type() const { + return _internal_has_packet_type(); +} +inline void PayloadTransferFrame::clear_packet_type() { + packet_type_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::location::nearby::connections::PayloadTransferFrame_PacketType PayloadTransferFrame::_internal_packet_type() const { + return static_cast< ::location::nearby::connections::PayloadTransferFrame_PacketType >(packet_type_); +} +inline ::location::nearby::connections::PayloadTransferFrame_PacketType PayloadTransferFrame::packet_type() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.packet_type) + return _internal_packet_type(); +} +inline void PayloadTransferFrame::_internal_set_packet_type(::location::nearby::connections::PayloadTransferFrame_PacketType value) { + assert(::location::nearby::connections::PayloadTransferFrame_PacketType_IsValid(value)); + _has_bits_[0] |= 0x00000008u; + packet_type_ = value; +} +inline void PayloadTransferFrame::set_packet_type(::location::nearby::connections::PayloadTransferFrame_PacketType value) { + _internal_set_packet_type(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.PayloadTransferFrame.packet_type) +} + +// optional .location.nearby.connections.PayloadTransferFrame.PayloadHeader payload_header = 2; +inline bool PayloadTransferFrame::_internal_has_payload_header() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || payload_header_ != nullptr); + return value; +} +inline bool PayloadTransferFrame::has_payload_header() const { + return _internal_has_payload_header(); +} +inline void PayloadTransferFrame::clear_payload_header() { + if (payload_header_ != nullptr) payload_header_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::location::nearby::connections::PayloadTransferFrame_PayloadHeader& PayloadTransferFrame::_internal_payload_header() const { + const ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* p = payload_header_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_PayloadTransferFrame_PayloadHeader_default_instance_); +} +inline const ::location::nearby::connections::PayloadTransferFrame_PayloadHeader& PayloadTransferFrame::payload_header() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.payload_header) + return _internal_payload_header(); +} +inline void PayloadTransferFrame::unsafe_arena_set_allocated_payload_header( + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* payload_header) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(payload_header_); + } + payload_header_ = payload_header; + if (payload_header) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.PayloadTransferFrame.payload_header) +} +inline ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* PayloadTransferFrame::release_payload_header() { + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* temp = payload_header_; + payload_header_ = 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 ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* PayloadTransferFrame::unsafe_arena_release_payload_header() { + // @@protoc_insertion_point(field_release:location.nearby.connections.PayloadTransferFrame.payload_header) + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* temp = payload_header_; + payload_header_ = nullptr; + return temp; +} +inline ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* PayloadTransferFrame::_internal_mutable_payload_header() { + _has_bits_[0] |= 0x00000001u; + if (payload_header_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame_PayloadHeader>(GetArenaForAllocation()); + payload_header_ = p; + } + return payload_header_; +} +inline ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* PayloadTransferFrame::mutable_payload_header() { + ::location::nearby::connections::PayloadTransferFrame_PayloadHeader* _msg = _internal_mutable_payload_header(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.PayloadTransferFrame.payload_header) + return _msg; +} +inline void PayloadTransferFrame::set_allocated_payload_header(::location::nearby::connections::PayloadTransferFrame_PayloadHeader* payload_header) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete payload_header_; + } + if (payload_header) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::PayloadTransferFrame_PayloadHeader>::GetOwningArena(payload_header); + if (message_arena != submessage_arena) { + payload_header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, payload_header, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + payload_header_ = payload_header; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.PayloadTransferFrame.payload_header) +} + +// optional .location.nearby.connections.PayloadTransferFrame.PayloadChunk payload_chunk = 3; +inline bool PayloadTransferFrame::_internal_has_payload_chunk() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || payload_chunk_ != nullptr); + return value; +} +inline bool PayloadTransferFrame::has_payload_chunk() const { + return _internal_has_payload_chunk(); +} +inline void PayloadTransferFrame::clear_payload_chunk() { + if (payload_chunk_ != nullptr) payload_chunk_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::location::nearby::connections::PayloadTransferFrame_PayloadChunk& PayloadTransferFrame::_internal_payload_chunk() const { + const ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* p = payload_chunk_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_PayloadTransferFrame_PayloadChunk_default_instance_); +} +inline const ::location::nearby::connections::PayloadTransferFrame_PayloadChunk& PayloadTransferFrame::payload_chunk() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.payload_chunk) + return _internal_payload_chunk(); +} +inline void PayloadTransferFrame::unsafe_arena_set_allocated_payload_chunk( + ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* payload_chunk) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(payload_chunk_); + } + payload_chunk_ = payload_chunk; + if (payload_chunk) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.PayloadTransferFrame.payload_chunk) +} +inline ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* PayloadTransferFrame::release_payload_chunk() { + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* temp = payload_chunk_; + payload_chunk_ = 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 ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* PayloadTransferFrame::unsafe_arena_release_payload_chunk() { + // @@protoc_insertion_point(field_release:location.nearby.connections.PayloadTransferFrame.payload_chunk) + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* temp = payload_chunk_; + payload_chunk_ = nullptr; + return temp; +} +inline ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* PayloadTransferFrame::_internal_mutable_payload_chunk() { + _has_bits_[0] |= 0x00000002u; + if (payload_chunk_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame_PayloadChunk>(GetArenaForAllocation()); + payload_chunk_ = p; + } + return payload_chunk_; +} +inline ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* PayloadTransferFrame::mutable_payload_chunk() { + ::location::nearby::connections::PayloadTransferFrame_PayloadChunk* _msg = _internal_mutable_payload_chunk(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.PayloadTransferFrame.payload_chunk) + return _msg; +} +inline void PayloadTransferFrame::set_allocated_payload_chunk(::location::nearby::connections::PayloadTransferFrame_PayloadChunk* payload_chunk) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete payload_chunk_; + } + if (payload_chunk) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::PayloadTransferFrame_PayloadChunk>::GetOwningArena(payload_chunk); + if (message_arena != submessage_arena) { + payload_chunk = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, payload_chunk, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + payload_chunk_ = payload_chunk; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.PayloadTransferFrame.payload_chunk) +} + +// optional .location.nearby.connections.PayloadTransferFrame.ControlMessage control_message = 4; +inline bool PayloadTransferFrame::_internal_has_control_message() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || control_message_ != nullptr); + return value; +} +inline bool PayloadTransferFrame::has_control_message() const { + return _internal_has_control_message(); +} +inline void PayloadTransferFrame::clear_control_message() { + if (control_message_ != nullptr) control_message_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::location::nearby::connections::PayloadTransferFrame_ControlMessage& PayloadTransferFrame::_internal_control_message() const { + const ::location::nearby::connections::PayloadTransferFrame_ControlMessage* p = control_message_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_PayloadTransferFrame_ControlMessage_default_instance_); +} +inline const ::location::nearby::connections::PayloadTransferFrame_ControlMessage& PayloadTransferFrame::control_message() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PayloadTransferFrame.control_message) + return _internal_control_message(); +} +inline void PayloadTransferFrame::unsafe_arena_set_allocated_control_message( + ::location::nearby::connections::PayloadTransferFrame_ControlMessage* control_message) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(control_message_); + } + control_message_ = control_message; + if (control_message) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.PayloadTransferFrame.control_message) +} +inline ::location::nearby::connections::PayloadTransferFrame_ControlMessage* PayloadTransferFrame::release_control_message() { + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::PayloadTransferFrame_ControlMessage* temp = control_message_; + control_message_ = 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 ::location::nearby::connections::PayloadTransferFrame_ControlMessage* PayloadTransferFrame::unsafe_arena_release_control_message() { + // @@protoc_insertion_point(field_release:location.nearby.connections.PayloadTransferFrame.control_message) + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::PayloadTransferFrame_ControlMessage* temp = control_message_; + control_message_ = nullptr; + return temp; +} +inline ::location::nearby::connections::PayloadTransferFrame_ControlMessage* PayloadTransferFrame::_internal_mutable_control_message() { + _has_bits_[0] |= 0x00000004u; + if (control_message_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame_ControlMessage>(GetArenaForAllocation()); + control_message_ = p; + } + return control_message_; +} +inline ::location::nearby::connections::PayloadTransferFrame_ControlMessage* PayloadTransferFrame::mutable_control_message() { + ::location::nearby::connections::PayloadTransferFrame_ControlMessage* _msg = _internal_mutable_control_message(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.PayloadTransferFrame.control_message) + return _msg; +} +inline void PayloadTransferFrame::set_allocated_control_message(::location::nearby::connections::PayloadTransferFrame_ControlMessage* control_message) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete control_message_; + } + if (control_message) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::PayloadTransferFrame_ControlMessage>::GetOwningArena(control_message); + if (message_arena != submessage_arena) { + control_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, control_message, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + control_message_ = control_message; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.PayloadTransferFrame.control_message) +} + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials + +// optional string ssid = 1; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_has_ssid() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::has_ssid() const { + return _internal_has_ssid(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::clear_ssid() { + ssid_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::ssid() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.ssid) + return _internal_ssid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::set_ssid(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + ssid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.ssid) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::mutable_ssid() { + std::string* _s = _internal_mutable_ssid(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.ssid) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_ssid() const { + return ssid_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_set_ssid(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + ssid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_mutable_ssid() { + _has_bits_[0] |= 0x00000001u; + return ssid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::release_ssid() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.ssid) + if (!_internal_has_ssid()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = ssid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ssid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + ssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::set_allocated_ssid(std::string* ssid) { + if (ssid != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + ssid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ssid, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ssid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + ssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.ssid) +} + +// optional string password = 2; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_has_password() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::has_password() const { + return _internal_has_password(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::clear_password() { + password_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::password() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.password) + return _internal_password(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::set_password(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.password) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::mutable_password() { + std::string* _s = _internal_mutable_password(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.password) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_password() const { + return password_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_set_password(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_mutable_password() { + _has_bits_[0] |= 0x00000002u; + return password_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::release_password() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.password) + if (!_internal_has_password()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = password_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (password_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::set_allocated_password(std::string* password) { + if (password != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + password_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), password, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (password_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.password) +} + +// optional int32 port = 3; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_has_port() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::has_port() const { + return _internal_has_port(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::clear_port() { + port_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_port() const { + return port_; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::port() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.port) + return _internal_port(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_set_port(int32_t value) { + _has_bits_[0] |= 0x00000008u; + port_ = value; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::set_port(int32_t value) { + _internal_set_port(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.port) +} + +// optional string gateway = 4 [default = "0.0.0.0"]; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_has_gateway() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::has_gateway() const { + return _internal_has_gateway(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::clear_gateway() { + gateway_.ClearToDefault(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_i_give_permission_to_break_this_code_default_gateway_, GetArenaForAllocation()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::gateway() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.gateway) + if (gateway_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_gateway_.get(); + return _internal_gateway(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::set_gateway(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + gateway_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.gateway) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::mutable_gateway() { + std::string* _s = _internal_mutable_gateway(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.gateway) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_gateway() const { + return gateway_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_set_gateway(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + gateway_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_mutable_gateway() { + _has_bits_[0] |= 0x00000004u; + return gateway_.Mutable(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_i_give_permission_to_break_this_code_default_gateway_, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::release_gateway() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.gateway) + if (!_internal_has_gateway()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = gateway_.ReleaseNonDefault(nullptr, GetArenaForAllocation()); + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::set_allocated_gateway(std::string* gateway) { + if (gateway != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + gateway_.SetAllocated(nullptr, gateway, + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.gateway) +} + +// optional int32 frequency = 5 [default = -1]; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_has_frequency() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::has_frequency() const { + return _internal_has_frequency(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::clear_frequency() { + frequency_ = -1; + _has_bits_[0] &= ~0x00000010u; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_frequency() const { + return frequency_; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::frequency() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.frequency) + return _internal_frequency(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::_internal_set_frequency(int32_t value) { + _has_bits_[0] |= 0x00000010u; + frequency_ = value; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials::set_frequency(int32_t value) { + _internal_set_frequency(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials.frequency) +} + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket + +// optional bytes ip_address = 1; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_internal_has_ip_address() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::has_ip_address() const { + return _internal_has_ip_address(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::clear_ip_address() { + ip_address_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::ip_address() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket.ip_address) + return _internal_ip_address(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::set_ip_address(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + ip_address_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket.ip_address) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::mutable_ip_address() { + std::string* _s = _internal_mutable_ip_address(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket.ip_address) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_internal_ip_address() const { + return ip_address_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_internal_set_ip_address(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + ip_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_internal_mutable_ip_address() { + _has_bits_[0] |= 0x00000001u; + return ip_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::release_ip_address() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket.ip_address) + if (!_internal_has_ip_address()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = ip_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ip_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::set_allocated_ip_address(std::string* ip_address) { + if (ip_address != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + ip_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip_address, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ip_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket.ip_address) +} + +// optional int32 wifi_port = 2; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_internal_has_wifi_port() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::has_wifi_port() const { + return _internal_has_wifi_port(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::clear_wifi_port() { + wifi_port_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_internal_wifi_port() const { + return wifi_port_; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::wifi_port() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket.wifi_port) + return _internal_wifi_port(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::_internal_set_wifi_port(int32_t value) { + _has_bits_[0] |= 0x00000002u; + wifi_port_ = value; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket::set_wifi_port(int32_t value) { + _internal_set_wifi_port(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket.wifi_port) +} + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials + +// optional string service_name = 1; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_internal_has_service_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::has_service_name() const { + return _internal_has_service_name(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::clear_service_name() { + service_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::service_name() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.service_name) + return _internal_service_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::set_service_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + service_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.service_name) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::mutable_service_name() { + std::string* _s = _internal_mutable_service_name(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.service_name) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_internal_service_name() const { + return service_name_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_internal_set_service_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + service_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_internal_mutable_service_name() { + _has_bits_[0] |= 0x00000001u; + return service_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::release_service_name() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.service_name) + if (!_internal_has_service_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = service_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (service_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + service_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::set_allocated_service_name(std::string* service_name) { + if (service_name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + service_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (service_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + service_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.service_name) +} + +// optional string mac_address = 2; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_internal_has_mac_address() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::has_mac_address() const { + return _internal_has_mac_address(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::clear_mac_address() { + mac_address_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::mac_address() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.mac_address) + return _internal_mac_address(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::set_mac_address(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + mac_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.mac_address) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::mutable_mac_address() { + std::string* _s = _internal_mutable_mac_address(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.mac_address) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_internal_mac_address() const { + return mac_address_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_internal_set_mac_address(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + mac_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::_internal_mutable_mac_address() { + _has_bits_[0] |= 0x00000002u; + return mac_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::release_mac_address() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.mac_address) + if (!_internal_has_mac_address()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = mac_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mac_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mac_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials::set_allocated_mac_address(std::string* mac_address) { + if (mac_address != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + mac_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mac_address, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (mac_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + mac_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials.mac_address) +} + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials + +// optional string service_id = 1; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_has_service_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::has_service_id() const { + return _internal_has_service_id(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::clear_service_id() { + service_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::service_id() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_id) + return _internal_service_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::set_service_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_id) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::mutable_service_id() { + std::string* _s = _internal_mutable_service_id(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_id) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_service_id() const { + return service_id_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_set_service_id(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_mutable_service_id() { + _has_bits_[0] |= 0x00000001u; + return service_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::release_service_id() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_id) + if (!_internal_has_service_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = service_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (service_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + service_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::set_allocated_service_id(std::string* service_id) { + if (service_id != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + service_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (service_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + service_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_id) +} + +// optional bytes service_info = 2; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_has_service_info() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::has_service_info() const { + return _internal_has_service_info(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::clear_service_info() { + service_info_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::service_info() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_info) + return _internal_service_info(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::set_service_info(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + service_info_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_info) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::mutable_service_info() { + std::string* _s = _internal_mutable_service_info(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_info) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_service_info() const { + return service_info_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_set_service_info(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + service_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_mutable_service_info() { + _has_bits_[0] |= 0x00000002u; + return service_info_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::release_service_info() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_info) + if (!_internal_has_service_info()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = service_info_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (service_info_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + service_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::set_allocated_service_info(std::string* service_info) { + if (service_info != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + service_info_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_info, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (service_info_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + service_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.service_info) +} + +// optional string password = 3; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_has_password() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::has_password() const { + return _internal_has_password(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::clear_password() { + password_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::password() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.password) + return _internal_password(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::set_password(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.password) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::mutable_password() { + std::string* _s = _internal_mutable_password(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.password) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_password() const { + return password_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_set_password(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::_internal_mutable_password() { + _has_bits_[0] |= 0x00000004u; + return password_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::release_password() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.password) + if (!_internal_has_password()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = password_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (password_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials::set_allocated_password(std::string* password) { + if (password != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + password_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), password, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (password_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials.password) +} + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials + +// optional string ssid = 1; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_has_ssid() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::has_ssid() const { + return _internal_has_ssid(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::clear_ssid() { + ssid_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::ssid() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.ssid) + return _internal_ssid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_ssid(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + ssid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.ssid) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::mutable_ssid() { + std::string* _s = _internal_mutable_ssid(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.ssid) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_ssid() const { + return ssid_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_set_ssid(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + ssid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_mutable_ssid() { + _has_bits_[0] |= 0x00000001u; + return ssid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::release_ssid() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.ssid) + if (!_internal_has_ssid()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = ssid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ssid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + ssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_allocated_ssid(std::string* ssid) { + if (ssid != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + ssid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ssid, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ssid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + ssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.ssid) +} + +// optional string password = 2; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_has_password() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::has_password() const { + return _internal_has_password(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::clear_password() { + password_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::password() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.password) + return _internal_password(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_password(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.password) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::mutable_password() { + std::string* _s = _internal_mutable_password(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.password) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_password() const { + return password_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_set_password(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_mutable_password() { + _has_bits_[0] |= 0x00000002u; + return password_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::release_password() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.password) + if (!_internal_has_password()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = password_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (password_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_allocated_password(std::string* password) { + if (password != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + password_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), password, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (password_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.password) +} + +// optional int32 port = 3; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_has_port() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::has_port() const { + return _internal_has_port(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::clear_port() { + port_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_port() const { + return port_; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::port() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.port) + return _internal_port(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_set_port(int32_t value) { + _has_bits_[0] |= 0x00000008u; + port_ = value; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_port(int32_t value) { + _internal_set_port(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.port) +} + +// optional int32 frequency = 4; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_has_frequency() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::has_frequency() const { + return _internal_has_frequency(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::clear_frequency() { + frequency_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_frequency() const { + return frequency_; +} +inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::frequency() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.frequency) + return _internal_frequency(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_set_frequency(int32_t value) { + _has_bits_[0] |= 0x00000010u; + frequency_ = value; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_frequency(int32_t value) { + _internal_set_frequency(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.frequency) +} + +// optional string gateway = 5 [default = "0.0.0.0"]; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_has_gateway() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::has_gateway() const { + return _internal_has_gateway(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::clear_gateway() { + gateway_.ClearToDefault(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_i_give_permission_to_break_this_code_default_gateway_, GetArenaForAllocation()); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::gateway() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.gateway) + if (gateway_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_gateway_.get(); + return _internal_gateway(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_gateway(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + gateway_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.gateway) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::mutable_gateway() { + std::string* _s = _internal_mutable_gateway(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.gateway) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_gateway() const { + return gateway_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_set_gateway(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + gateway_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_mutable_gateway() { + _has_bits_[0] |= 0x00000004u; + return gateway_.Mutable(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_i_give_permission_to_break_this_code_default_gateway_, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::release_gateway() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.gateway) + if (!_internal_has_gateway()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = gateway_.ReleaseNonDefault(nullptr, GetArenaForAllocation()); + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_allocated_gateway(std::string* gateway) { + if (gateway != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + gateway_.SetAllocated(nullptr, gateway, + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.gateway) +} + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials + +// optional string peer_id = 1; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_internal_has_peer_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::has_peer_id() const { + return _internal_has_peer_id(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::clear_peer_id() { + peer_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::peer_id() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.peer_id) + return _internal_peer_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::set_peer_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + peer_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.peer_id) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::mutable_peer_id() { + std::string* _s = _internal_mutable_peer_id(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.peer_id) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_internal_peer_id() const { + return peer_id_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_internal_set_peer_id(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + peer_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_internal_mutable_peer_id() { + _has_bits_[0] |= 0x00000001u; + return peer_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::release_peer_id() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.peer_id) + if (!_internal_has_peer_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = peer_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (peer_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + peer_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::set_allocated_peer_id(std::string* peer_id) { + if (peer_id != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + peer_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), peer_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (peer_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + peer_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.peer_id) +} + +// optional .location.nearby.connections.LocationHint location_hint = 2; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_internal_has_location_hint() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || location_hint_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::has_location_hint() const { + return _internal_has_location_hint(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::clear_location_hint() { + if (location_hint_ != nullptr) location_hint_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::location::nearby::connections::LocationHint& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_internal_location_hint() const { + const ::location::nearby::connections::LocationHint* p = location_hint_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_LocationHint_default_instance_); +} +inline const ::location::nearby::connections::LocationHint& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::location_hint() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.location_hint) + return _internal_location_hint(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::unsafe_arena_set_allocated_location_hint( + ::location::nearby::connections::LocationHint* location_hint) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(location_hint_); + } + location_hint_ = location_hint; + if (location_hint) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.location_hint) +} +inline ::location::nearby::connections::LocationHint* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::release_location_hint() { + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::LocationHint* temp = location_hint_; + location_hint_ = 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 ::location::nearby::connections::LocationHint* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::unsafe_arena_release_location_hint() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.location_hint) + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::LocationHint* temp = location_hint_; + location_hint_ = nullptr; + return temp; +} +inline ::location::nearby::connections::LocationHint* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::_internal_mutable_location_hint() { + _has_bits_[0] |= 0x00000002u; + if (location_hint_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::LocationHint>(GetArenaForAllocation()); + location_hint_ = p; + } + return location_hint_; +} +inline ::location::nearby::connections::LocationHint* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::mutable_location_hint() { + ::location::nearby::connections::LocationHint* _msg = _internal_mutable_location_hint(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.location_hint) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials::set_allocated_location_hint(::location::nearby::connections::LocationHint* location_hint) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete location_hint_; + } + if (location_hint) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::LocationHint>::GetOwningArena(location_hint); + if (message_arena != submessage_arena) { + location_hint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, location_hint, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + location_hint_ = location_hint; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials.location_hint) +} + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame_UpgradePathInfo + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.Medium medium = 1; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_has_medium() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::has_medium() const { + return _internal_has_medium(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::clear_medium() { + medium_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_medium() const { + return static_cast< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium >(medium_); +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium BandwidthUpgradeNegotiationFrame_UpgradePathInfo::medium() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.medium) + return _internal_medium(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_set_medium(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium value) { + assert(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium_IsValid(value)); + _has_bits_[0] |= 0x00000040u; + medium_ = value; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::set_medium(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium value) { + _internal_set_medium(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.medium) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiHotspotCredentials wifi_hotspot_credentials = 2; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_has_wifi_hotspot_credentials() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || wifi_hotspot_credentials_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::has_wifi_hotspot_credentials() const { + return _internal_has_wifi_hotspot_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::clear_wifi_hotspot_credentials() { + if (wifi_hotspot_credentials_ != nullptr) wifi_hotspot_credentials_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_wifi_hotspot_credentials() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* p = wifi_hotspot_credentials_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::wifi_hotspot_credentials() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_hotspot_credentials) + return _internal_wifi_hotspot_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_set_allocated_wifi_hotspot_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* wifi_hotspot_credentials) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wifi_hotspot_credentials_); + } + wifi_hotspot_credentials_ = wifi_hotspot_credentials; + if (wifi_hotspot_credentials) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_hotspot_credentials) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::release_wifi_hotspot_credentials() { + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* temp = wifi_hotspot_credentials_; + wifi_hotspot_credentials_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_release_wifi_hotspot_credentials() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_hotspot_credentials) + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* temp = wifi_hotspot_credentials_; + wifi_hotspot_credentials_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_mutable_wifi_hotspot_credentials() { + _has_bits_[0] |= 0x00000001u; + if (wifi_hotspot_credentials_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials>(GetArenaForAllocation()); + wifi_hotspot_credentials_ = p; + } + return wifi_hotspot_credentials_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::mutable_wifi_hotspot_credentials() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* _msg = _internal_mutable_wifi_hotspot_credentials(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_hotspot_credentials) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::set_allocated_wifi_hotspot_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* wifi_hotspot_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete wifi_hotspot_credentials_; + } + if (wifi_hotspot_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials>::GetOwningArena(wifi_hotspot_credentials); + if (message_arena != submessage_arena) { + wifi_hotspot_credentials = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wifi_hotspot_credentials, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + wifi_hotspot_credentials_ = wifi_hotspot_credentials; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_hotspot_credentials) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiLanSocket wifi_lan_socket = 3; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_has_wifi_lan_socket() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || wifi_lan_socket_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::has_wifi_lan_socket() const { + return _internal_has_wifi_lan_socket(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::clear_wifi_lan_socket() { + if (wifi_lan_socket_ != nullptr) wifi_lan_socket_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_wifi_lan_socket() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* p = wifi_lan_socket_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::wifi_lan_socket() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_lan_socket) + return _internal_wifi_lan_socket(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_set_allocated_wifi_lan_socket( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* wifi_lan_socket) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wifi_lan_socket_); + } + wifi_lan_socket_ = wifi_lan_socket; + if (wifi_lan_socket) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_lan_socket) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::release_wifi_lan_socket() { + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* temp = wifi_lan_socket_; + wifi_lan_socket_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_release_wifi_lan_socket() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_lan_socket) + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* temp = wifi_lan_socket_; + wifi_lan_socket_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_mutable_wifi_lan_socket() { + _has_bits_[0] |= 0x00000002u; + if (wifi_lan_socket_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket>(GetArenaForAllocation()); + wifi_lan_socket_ = p; + } + return wifi_lan_socket_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::mutable_wifi_lan_socket() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* _msg = _internal_mutable_wifi_lan_socket(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_lan_socket) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::set_allocated_wifi_lan_socket(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* wifi_lan_socket) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete wifi_lan_socket_; + } + if (wifi_lan_socket) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket>::GetOwningArena(wifi_lan_socket); + if (message_arena != submessage_arena) { + wifi_lan_socket = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wifi_lan_socket, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + wifi_lan_socket_ = wifi_lan_socket; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_lan_socket) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.BluetoothCredentials bluetooth_credentials = 4; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_has_bluetooth_credentials() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || bluetooth_credentials_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::has_bluetooth_credentials() const { + return _internal_has_bluetooth_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::clear_bluetooth_credentials() { + if (bluetooth_credentials_ != nullptr) bluetooth_credentials_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_bluetooth_credentials() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* p = bluetooth_credentials_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::bluetooth_credentials() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.bluetooth_credentials) + return _internal_bluetooth_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_set_allocated_bluetooth_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* bluetooth_credentials) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bluetooth_credentials_); + } + bluetooth_credentials_ = bluetooth_credentials; + if (bluetooth_credentials) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.bluetooth_credentials) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::release_bluetooth_credentials() { + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* temp = bluetooth_credentials_; + bluetooth_credentials_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_release_bluetooth_credentials() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.bluetooth_credentials) + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* temp = bluetooth_credentials_; + bluetooth_credentials_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_mutable_bluetooth_credentials() { + _has_bits_[0] |= 0x00000004u; + if (bluetooth_credentials_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials>(GetArenaForAllocation()); + bluetooth_credentials_ = p; + } + return bluetooth_credentials_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::mutable_bluetooth_credentials() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* _msg = _internal_mutable_bluetooth_credentials(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.bluetooth_credentials) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::set_allocated_bluetooth_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials* bluetooth_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete bluetooth_credentials_; + } + if (bluetooth_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_BluetoothCredentials>::GetOwningArena(bluetooth_credentials); + if (message_arena != submessage_arena) { + bluetooth_credentials = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bluetooth_credentials, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + bluetooth_credentials_ = bluetooth_credentials; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.bluetooth_credentials) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiAwareCredentials wifi_aware_credentials = 5; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_has_wifi_aware_credentials() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || wifi_aware_credentials_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::has_wifi_aware_credentials() const { + return _internal_has_wifi_aware_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::clear_wifi_aware_credentials() { + if (wifi_aware_credentials_ != nullptr) wifi_aware_credentials_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_wifi_aware_credentials() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* p = wifi_aware_credentials_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::wifi_aware_credentials() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_aware_credentials) + return _internal_wifi_aware_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_set_allocated_wifi_aware_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* wifi_aware_credentials) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wifi_aware_credentials_); + } + wifi_aware_credentials_ = wifi_aware_credentials; + if (wifi_aware_credentials) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_aware_credentials) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::release_wifi_aware_credentials() { + _has_bits_[0] &= ~0x00000008u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* temp = wifi_aware_credentials_; + wifi_aware_credentials_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_release_wifi_aware_credentials() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_aware_credentials) + _has_bits_[0] &= ~0x00000008u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* temp = wifi_aware_credentials_; + wifi_aware_credentials_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_mutable_wifi_aware_credentials() { + _has_bits_[0] |= 0x00000008u; + if (wifi_aware_credentials_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials>(GetArenaForAllocation()); + wifi_aware_credentials_ = p; + } + return wifi_aware_credentials_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::mutable_wifi_aware_credentials() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* _msg = _internal_mutable_wifi_aware_credentials(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_aware_credentials) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::set_allocated_wifi_aware_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials* wifi_aware_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete wifi_aware_credentials_; + } + if (wifi_aware_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiAwareCredentials>::GetOwningArena(wifi_aware_credentials); + if (message_arena != submessage_arena) { + wifi_aware_credentials = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wifi_aware_credentials, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + wifi_aware_credentials_ = wifi_aware_credentials; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_aware_credentials) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials wifi_direct_credentials = 6; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_has_wifi_direct_credentials() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || wifi_direct_credentials_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::has_wifi_direct_credentials() const { + return _internal_has_wifi_direct_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::clear_wifi_direct_credentials() { + if (wifi_direct_credentials_ != nullptr) wifi_direct_credentials_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_wifi_direct_credentials() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* p = wifi_direct_credentials_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::wifi_direct_credentials() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_direct_credentials) + return _internal_wifi_direct_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_set_allocated_wifi_direct_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* wifi_direct_credentials) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wifi_direct_credentials_); + } + wifi_direct_credentials_ = wifi_direct_credentials; + if (wifi_direct_credentials) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_direct_credentials) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::release_wifi_direct_credentials() { + _has_bits_[0] &= ~0x00000010u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* temp = wifi_direct_credentials_; + wifi_direct_credentials_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_release_wifi_direct_credentials() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_direct_credentials) + _has_bits_[0] &= ~0x00000010u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* temp = wifi_direct_credentials_; + wifi_direct_credentials_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_mutable_wifi_direct_credentials() { + _has_bits_[0] |= 0x00000010u; + if (wifi_direct_credentials_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials>(GetArenaForAllocation()); + wifi_direct_credentials_ = p; + } + return wifi_direct_credentials_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::mutable_wifi_direct_credentials() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* _msg = _internal_mutable_wifi_direct_credentials(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_direct_credentials) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::set_allocated_wifi_direct_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* wifi_direct_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete wifi_direct_credentials_; + } + if (wifi_direct_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials>::GetOwningArena(wifi_direct_credentials); + if (message_arena != submessage_arena) { + wifi_direct_credentials = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wifi_direct_credentials, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + wifi_direct_credentials_ = wifi_direct_credentials; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.wifi_direct_credentials) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WebRtcCredentials web_rtc_credentials = 8; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_has_web_rtc_credentials() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || web_rtc_credentials_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::has_web_rtc_credentials() const { + return _internal_has_web_rtc_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::clear_web_rtc_credentials() { + if (web_rtc_credentials_ != nullptr) web_rtc_credentials_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_web_rtc_credentials() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* p = web_rtc_credentials_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials& BandwidthUpgradeNegotiationFrame_UpgradePathInfo::web_rtc_credentials() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.web_rtc_credentials) + return _internal_web_rtc_credentials(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_set_allocated_web_rtc_credentials( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* web_rtc_credentials) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(web_rtc_credentials_); + } + web_rtc_credentials_ = web_rtc_credentials; + if (web_rtc_credentials) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.web_rtc_credentials) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::release_web_rtc_credentials() { + _has_bits_[0] &= ~0x00000020u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* temp = web_rtc_credentials_; + web_rtc_credentials_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::unsafe_arena_release_web_rtc_credentials() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.web_rtc_credentials) + _has_bits_[0] &= ~0x00000020u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* temp = web_rtc_credentials_; + web_rtc_credentials_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_mutable_web_rtc_credentials() { + _has_bits_[0] |= 0x00000020u; + if (web_rtc_credentials_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials>(GetArenaForAllocation()); + web_rtc_credentials_ = p; + } + return web_rtc_credentials_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* BandwidthUpgradeNegotiationFrame_UpgradePathInfo::mutable_web_rtc_credentials() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* _msg = _internal_mutable_web_rtc_credentials(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.web_rtc_credentials) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::set_allocated_web_rtc_credentials(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials* web_rtc_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete web_rtc_credentials_; + } + if (web_rtc_credentials) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials>::GetOwningArena(web_rtc_credentials); + if (message_arena != submessage_arena) { + web_rtc_credentials = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, web_rtc_credentials, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + web_rtc_credentials_ = web_rtc_credentials; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.web_rtc_credentials) +} + +// optional bool supports_disabling_encryption = 7; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_has_supports_disabling_encryption() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::has_supports_disabling_encryption() const { + return _internal_has_supports_disabling_encryption(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::clear_supports_disabling_encryption() { + supports_disabling_encryption_ = false; + _has_bits_[0] &= ~0x00000080u; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_supports_disabling_encryption() const { + return supports_disabling_encryption_; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::supports_disabling_encryption() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.supports_disabling_encryption) + return _internal_supports_disabling_encryption(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_set_supports_disabling_encryption(bool value) { + _has_bits_[0] |= 0x00000080u; + supports_disabling_encryption_ = value; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::set_supports_disabling_encryption(bool value) { + _internal_set_supports_disabling_encryption(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.supports_disabling_encryption) +} + +// optional bool supports_client_introduction_ack = 9; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_has_supports_client_introduction_ack() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::has_supports_client_introduction_ack() const { + return _internal_has_supports_client_introduction_ack(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::clear_supports_client_introduction_ack() { + supports_client_introduction_ack_ = false; + _has_bits_[0] &= ~0x00000100u; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_supports_client_introduction_ack() const { + return supports_client_introduction_ack_; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo::supports_client_introduction_ack() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.supports_client_introduction_ack) + return _internal_supports_client_introduction_ack(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::_internal_set_supports_client_introduction_ack(bool value) { + _has_bits_[0] |= 0x00000100u; + supports_client_introduction_ack_ = value; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo::set_supports_client_introduction_ack(bool value) { + _internal_set_supports_client_introduction_ack(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.supports_client_introduction_ack) +} + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame_ClientIntroduction + +// optional string endpoint_id = 1; +inline bool BandwidthUpgradeNegotiationFrame_ClientIntroduction::_internal_has_endpoint_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_ClientIntroduction::has_endpoint_id() const { + return _internal_has_endpoint_id(); +} +inline void BandwidthUpgradeNegotiationFrame_ClientIntroduction::clear_endpoint_id() { + endpoint_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_ClientIntroduction::endpoint_id() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction.endpoint_id) + return _internal_endpoint_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_ClientIntroduction::set_endpoint_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction.endpoint_id) +} +inline std::string* BandwidthUpgradeNegotiationFrame_ClientIntroduction::mutable_endpoint_id() { + std::string* _s = _internal_mutable_endpoint_id(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction.endpoint_id) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_ClientIntroduction::_internal_endpoint_id() const { + return endpoint_id_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_ClientIntroduction::_internal_set_endpoint_id(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_ClientIntroduction::_internal_mutable_endpoint_id() { + _has_bits_[0] |= 0x00000001u; + return endpoint_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_ClientIntroduction::release_endpoint_id() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction.endpoint_id) + if (!_internal_has_endpoint_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = endpoint_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_ClientIntroduction::set_allocated_endpoint_id(std::string* endpoint_id) { + if (endpoint_id != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + endpoint_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), endpoint_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (endpoint_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction.endpoint_id) +} + +// optional bool supports_disabling_encryption = 2; +inline bool BandwidthUpgradeNegotiationFrame_ClientIntroduction::_internal_has_supports_disabling_encryption() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_ClientIntroduction::has_supports_disabling_encryption() const { + return _internal_has_supports_disabling_encryption(); +} +inline void BandwidthUpgradeNegotiationFrame_ClientIntroduction::clear_supports_disabling_encryption() { + supports_disabling_encryption_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool BandwidthUpgradeNegotiationFrame_ClientIntroduction::_internal_supports_disabling_encryption() const { + return supports_disabling_encryption_; +} +inline bool BandwidthUpgradeNegotiationFrame_ClientIntroduction::supports_disabling_encryption() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction.supports_disabling_encryption) + return _internal_supports_disabling_encryption(); +} +inline void BandwidthUpgradeNegotiationFrame_ClientIntroduction::_internal_set_supports_disabling_encryption(bool value) { + _has_bits_[0] |= 0x00000002u; + supports_disabling_encryption_ = value; +} +inline void BandwidthUpgradeNegotiationFrame_ClientIntroduction::set_supports_disabling_encryption(bool value) { + _internal_set_supports_disabling_encryption(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction.supports_disabling_encryption) +} + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame_ClientIntroductionAck + +// ------------------------------------------------------------------- + +// BandwidthUpgradeNegotiationFrame + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.EventType event_type = 1; +inline bool BandwidthUpgradeNegotiationFrame::_internal_has_event_type() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame::has_event_type() const { + return _internal_has_event_type(); +} +inline void BandwidthUpgradeNegotiationFrame::clear_event_type() { + event_type_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::_internal_event_type() const { + return static_cast< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType >(event_type_); +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::event_type() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.event_type) + return _internal_event_type(); +} +inline void BandwidthUpgradeNegotiationFrame::_internal_set_event_type(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType value) { + assert(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType_IsValid(value)); + _has_bits_[0] |= 0x00000008u; + event_type_ = value; +} +inline void BandwidthUpgradeNegotiationFrame::set_event_type(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType value) { + _internal_set_event_type(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.event_type) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo upgrade_path_info = 2; +inline bool BandwidthUpgradeNegotiationFrame::_internal_has_upgrade_path_info() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || upgrade_path_info_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame::has_upgrade_path_info() const { + return _internal_has_upgrade_path_info(); +} +inline void BandwidthUpgradeNegotiationFrame::clear_upgrade_path_info() { + if (upgrade_path_info_ != nullptr) upgrade_path_info_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo& BandwidthUpgradeNegotiationFrame::_internal_upgrade_path_info() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* p = upgrade_path_info_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_UpgradePathInfo_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo& BandwidthUpgradeNegotiationFrame::upgrade_path_info() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.upgrade_path_info) + return _internal_upgrade_path_info(); +} +inline void BandwidthUpgradeNegotiationFrame::unsafe_arena_set_allocated_upgrade_path_info( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* upgrade_path_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upgrade_path_info_); + } + upgrade_path_info_ = upgrade_path_info; + if (upgrade_path_info) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.upgrade_path_info) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* BandwidthUpgradeNegotiationFrame::release_upgrade_path_info() { + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* temp = upgrade_path_info_; + upgrade_path_info_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* BandwidthUpgradeNegotiationFrame::unsafe_arena_release_upgrade_path_info() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.upgrade_path_info) + _has_bits_[0] &= ~0x00000001u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* temp = upgrade_path_info_; + upgrade_path_info_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* BandwidthUpgradeNegotiationFrame::_internal_mutable_upgrade_path_info() { + _has_bits_[0] |= 0x00000001u; + if (upgrade_path_info_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo>(GetArenaForAllocation()); + upgrade_path_info_ = p; + } + return upgrade_path_info_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* BandwidthUpgradeNegotiationFrame::mutable_upgrade_path_info() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* _msg = _internal_mutable_upgrade_path_info(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.upgrade_path_info) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame::set_allocated_upgrade_path_info(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo* upgrade_path_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete upgrade_path_info_; + } + if (upgrade_path_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo>::GetOwningArena(upgrade_path_info); + if (message_arena != submessage_arena) { + upgrade_path_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, upgrade_path_info, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + upgrade_path_info_ = upgrade_path_info; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.upgrade_path_info) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroduction client_introduction = 3; +inline bool BandwidthUpgradeNegotiationFrame::_internal_has_client_introduction() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || client_introduction_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame::has_client_introduction() const { + return _internal_has_client_introduction(); +} +inline void BandwidthUpgradeNegotiationFrame::clear_client_introduction() { + if (client_introduction_ != nullptr) client_introduction_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction& BandwidthUpgradeNegotiationFrame::_internal_client_introduction() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* p = client_introduction_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_ClientIntroduction_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction& BandwidthUpgradeNegotiationFrame::client_introduction() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction) + return _internal_client_introduction(); +} +inline void BandwidthUpgradeNegotiationFrame::unsafe_arena_set_allocated_client_introduction( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* client_introduction) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_introduction_); + } + client_introduction_ = client_introduction; + if (client_introduction) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* BandwidthUpgradeNegotiationFrame::release_client_introduction() { + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* temp = client_introduction_; + client_introduction_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* BandwidthUpgradeNegotiationFrame::unsafe_arena_release_client_introduction() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction) + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* temp = client_introduction_; + client_introduction_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* BandwidthUpgradeNegotiationFrame::_internal_mutable_client_introduction() { + _has_bits_[0] |= 0x00000002u; + if (client_introduction_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction>(GetArenaForAllocation()); + client_introduction_ = p; + } + return client_introduction_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* BandwidthUpgradeNegotiationFrame::mutable_client_introduction() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* _msg = _internal_mutable_client_introduction(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame::set_allocated_client_introduction(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction* client_introduction) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete client_introduction_; + } + if (client_introduction) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroduction>::GetOwningArena(client_introduction); + if (message_arena != submessage_arena) { + client_introduction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, client_introduction, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + client_introduction_ = client_introduction; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction) +} + +// optional .location.nearby.connections.BandwidthUpgradeNegotiationFrame.ClientIntroductionAck client_introduction_ack = 4; +inline bool BandwidthUpgradeNegotiationFrame::_internal_has_client_introduction_ack() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || client_introduction_ack_ != nullptr); + return value; +} +inline bool BandwidthUpgradeNegotiationFrame::has_client_introduction_ack() const { + return _internal_has_client_introduction_ack(); +} +inline void BandwidthUpgradeNegotiationFrame::clear_client_introduction_ack() { + if (client_introduction_ack_ != nullptr) client_introduction_ack_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& BandwidthUpgradeNegotiationFrame::_internal_client_introduction_ack() const { + const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* p = client_introduction_ack_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_BandwidthUpgradeNegotiationFrame_ClientIntroductionAck_default_instance_); +} +inline const ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck& BandwidthUpgradeNegotiationFrame::client_introduction_ack() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction_ack) + return _internal_client_introduction_ack(); +} +inline void BandwidthUpgradeNegotiationFrame::unsafe_arena_set_allocated_client_introduction_ack( + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* client_introduction_ack) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_introduction_ack_); + } + client_introduction_ack_ = client_introduction_ack; + if (client_introduction_ack) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction_ack) +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* BandwidthUpgradeNegotiationFrame::release_client_introduction_ack() { + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* temp = client_introduction_ack_; + client_introduction_ack_ = 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 ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* BandwidthUpgradeNegotiationFrame::unsafe_arena_release_client_introduction_ack() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction_ack) + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* temp = client_introduction_ack_; + client_introduction_ack_ = nullptr; + return temp; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* BandwidthUpgradeNegotiationFrame::_internal_mutable_client_introduction_ack() { + _has_bits_[0] |= 0x00000004u; + if (client_introduction_ack_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck>(GetArenaForAllocation()); + client_introduction_ack_ = p; + } + return client_introduction_ack_; +} +inline ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* BandwidthUpgradeNegotiationFrame::mutable_client_introduction_ack() { + ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* _msg = _internal_mutable_client_introduction_ack(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction_ack) + return _msg; +} +inline void BandwidthUpgradeNegotiationFrame::set_allocated_client_introduction_ack(::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck* client_introduction_ack) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete client_introduction_ack_; + } + if (client_introduction_ack) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_ClientIntroductionAck>::GetOwningArena(client_introduction_ack); + if (message_arena != submessage_arena) { + client_introduction_ack = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, client_introduction_ack, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + client_introduction_ack_ = client_introduction_ack; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.client_introduction_ack) +} + +// ------------------------------------------------------------------- + +// KeepAliveFrame + +// optional bool ack = 1; +inline bool KeepAliveFrame::_internal_has_ack() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool KeepAliveFrame::has_ack() const { + return _internal_has_ack(); +} +inline void KeepAliveFrame::clear_ack() { + ack_ = false; + _has_bits_[0] &= ~0x00000001u; +} +inline bool KeepAliveFrame::_internal_ack() const { + return ack_; +} +inline bool KeepAliveFrame::ack() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.KeepAliveFrame.ack) + return _internal_ack(); +} +inline void KeepAliveFrame::_internal_set_ack(bool value) { + _has_bits_[0] |= 0x00000001u; + ack_ = value; +} +inline void KeepAliveFrame::set_ack(bool value) { + _internal_set_ack(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.KeepAliveFrame.ack) +} + +// ------------------------------------------------------------------- + +// DisconnectionFrame + +// ------------------------------------------------------------------- + +// PairedKeyEncryptionFrame + +// optional bytes signed_data = 1; +inline bool PairedKeyEncryptionFrame::_internal_has_signed_data() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool PairedKeyEncryptionFrame::has_signed_data() const { + return _internal_has_signed_data(); +} +inline void PairedKeyEncryptionFrame::clear_signed_data() { + signed_data_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& PairedKeyEncryptionFrame::signed_data() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.PairedKeyEncryptionFrame.signed_data) + return _internal_signed_data(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void PairedKeyEncryptionFrame::set_signed_data(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + signed_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.PairedKeyEncryptionFrame.signed_data) +} +inline std::string* PairedKeyEncryptionFrame::mutable_signed_data() { + std::string* _s = _internal_mutable_signed_data(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.PairedKeyEncryptionFrame.signed_data) + return _s; +} +inline const std::string& PairedKeyEncryptionFrame::_internal_signed_data() const { + return signed_data_.Get(); +} +inline void PairedKeyEncryptionFrame::_internal_set_signed_data(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + signed_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* PairedKeyEncryptionFrame::_internal_mutable_signed_data() { + _has_bits_[0] |= 0x00000001u; + return signed_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* PairedKeyEncryptionFrame::release_signed_data() { + // @@protoc_insertion_point(field_release:location.nearby.connections.PairedKeyEncryptionFrame.signed_data) + if (!_internal_has_signed_data()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = signed_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (signed_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + signed_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void PairedKeyEncryptionFrame::set_allocated_signed_data(std::string* signed_data) { + if (signed_data != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + signed_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signed_data, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (signed_data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + signed_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.PairedKeyEncryptionFrame.signed_data) +} + +// ------------------------------------------------------------------- + +// MediumMetadata + +// optional bool supports_5_ghz = 1; +inline bool MediumMetadata::_internal_has_supports_5_ghz() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool MediumMetadata::has_supports_5_ghz() const { + return _internal_has_supports_5_ghz(); +} +inline void MediumMetadata::clear_supports_5_ghz() { + supports_5_ghz_ = false; + _has_bits_[0] &= ~0x00000080u; +} +inline bool MediumMetadata::_internal_supports_5_ghz() const { + return supports_5_ghz_; +} +inline bool MediumMetadata::supports_5_ghz() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.supports_5_ghz) + return _internal_supports_5_ghz(); +} +inline void MediumMetadata::_internal_set_supports_5_ghz(bool value) { + _has_bits_[0] |= 0x00000080u; + supports_5_ghz_ = value; +} +inline void MediumMetadata::set_supports_5_ghz(bool value) { + _internal_set_supports_5_ghz(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.MediumMetadata.supports_5_ghz) +} + +// optional string bssid = 2; +inline bool MediumMetadata::_internal_has_bssid() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool MediumMetadata::has_bssid() const { + return _internal_has_bssid(); +} +inline void MediumMetadata::clear_bssid() { + bssid_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& MediumMetadata::bssid() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.bssid) + return _internal_bssid(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MediumMetadata::set_bssid(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + bssid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.MediumMetadata.bssid) +} +inline std::string* MediumMetadata::mutable_bssid() { + std::string* _s = _internal_mutable_bssid(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.MediumMetadata.bssid) + return _s; +} +inline const std::string& MediumMetadata::_internal_bssid() const { + return bssid_.Get(); +} +inline void MediumMetadata::_internal_set_bssid(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + bssid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* MediumMetadata::_internal_mutable_bssid() { + _has_bits_[0] |= 0x00000001u; + return bssid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* MediumMetadata::release_bssid() { + // @@protoc_insertion_point(field_release:location.nearby.connections.MediumMetadata.bssid) + if (!_internal_has_bssid()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = bssid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (bssid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + bssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MediumMetadata::set_allocated_bssid(std::string* bssid) { + if (bssid != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + bssid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bssid, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (bssid_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + bssid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.MediumMetadata.bssid) +} + +// optional bytes ip_address = 3; +inline bool MediumMetadata::_internal_has_ip_address() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool MediumMetadata::has_ip_address() const { + return _internal_has_ip_address(); +} +inline void MediumMetadata::clear_ip_address() { + ip_address_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& MediumMetadata::ip_address() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.ip_address) + return _internal_ip_address(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void MediumMetadata::set_ip_address(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + ip_address_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.MediumMetadata.ip_address) +} +inline std::string* MediumMetadata::mutable_ip_address() { + std::string* _s = _internal_mutable_ip_address(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.MediumMetadata.ip_address) + return _s; +} +inline const std::string& MediumMetadata::_internal_ip_address() const { + return ip_address_.Get(); +} +inline void MediumMetadata::_internal_set_ip_address(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + ip_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* MediumMetadata::_internal_mutable_ip_address() { + _has_bits_[0] |= 0x00000002u; + return ip_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* MediumMetadata::release_ip_address() { + // @@protoc_insertion_point(field_release:location.nearby.connections.MediumMetadata.ip_address) + if (!_internal_has_ip_address()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = ip_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ip_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void MediumMetadata::set_allocated_ip_address(std::string* ip_address) { + if (ip_address != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + ip_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ip_address, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ip_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + ip_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.MediumMetadata.ip_address) +} + +// optional bool supports_6_ghz = 4; +inline bool MediumMetadata::_internal_has_supports_6_ghz() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool MediumMetadata::has_supports_6_ghz() const { + return _internal_has_supports_6_ghz(); +} +inline void MediumMetadata::clear_supports_6_ghz() { + supports_6_ghz_ = false; + _has_bits_[0] &= ~0x00000100u; +} +inline bool MediumMetadata::_internal_supports_6_ghz() const { + return supports_6_ghz_; +} +inline bool MediumMetadata::supports_6_ghz() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.supports_6_ghz) + return _internal_supports_6_ghz(); +} +inline void MediumMetadata::_internal_set_supports_6_ghz(bool value) { + _has_bits_[0] |= 0x00000100u; + supports_6_ghz_ = value; +} +inline void MediumMetadata::set_supports_6_ghz(bool value) { + _internal_set_supports_6_ghz(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.MediumMetadata.supports_6_ghz) +} + +// optional bool mobile_radio = 5; +inline bool MediumMetadata::_internal_has_mobile_radio() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool MediumMetadata::has_mobile_radio() const { + return _internal_has_mobile_radio(); +} +inline void MediumMetadata::clear_mobile_radio() { + mobile_radio_ = false; + _has_bits_[0] &= ~0x00000200u; +} +inline bool MediumMetadata::_internal_mobile_radio() const { + return mobile_radio_; +} +inline bool MediumMetadata::mobile_radio() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.mobile_radio) + return _internal_mobile_radio(); +} +inline void MediumMetadata::_internal_set_mobile_radio(bool value) { + _has_bits_[0] |= 0x00000200u; + mobile_radio_ = value; +} +inline void MediumMetadata::set_mobile_radio(bool value) { + _internal_set_mobile_radio(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.MediumMetadata.mobile_radio) +} + +// optional int32 ap_frequency = 6 [default = -1]; +inline bool MediumMetadata::_internal_has_ap_frequency() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool MediumMetadata::has_ap_frequency() const { + return _internal_has_ap_frequency(); +} +inline void MediumMetadata::clear_ap_frequency() { + ap_frequency_ = -1; + _has_bits_[0] &= ~0x00000400u; +} +inline int32_t MediumMetadata::_internal_ap_frequency() const { + return ap_frequency_; +} +inline int32_t MediumMetadata::ap_frequency() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.ap_frequency) + return _internal_ap_frequency(); +} +inline void MediumMetadata::_internal_set_ap_frequency(int32_t value) { + _has_bits_[0] |= 0x00000400u; + ap_frequency_ = value; +} +inline void MediumMetadata::set_ap_frequency(int32_t value) { + _internal_set_ap_frequency(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.MediumMetadata.ap_frequency) +} + +// optional .location.nearby.connections.AvailableChannels available_channels = 7; +inline bool MediumMetadata::_internal_has_available_channels() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || available_channels_ != nullptr); + return value; +} +inline bool MediumMetadata::has_available_channels() const { + return _internal_has_available_channels(); +} +inline void MediumMetadata::clear_available_channels() { + if (available_channels_ != nullptr) available_channels_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::location::nearby::connections::AvailableChannels& MediumMetadata::_internal_available_channels() const { + const ::location::nearby::connections::AvailableChannels* p = available_channels_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_AvailableChannels_default_instance_); +} +inline const ::location::nearby::connections::AvailableChannels& MediumMetadata::available_channels() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.available_channels) + return _internal_available_channels(); +} +inline void MediumMetadata::unsafe_arena_set_allocated_available_channels( + ::location::nearby::connections::AvailableChannels* available_channels) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(available_channels_); + } + available_channels_ = available_channels; + if (available_channels) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.MediumMetadata.available_channels) +} +inline ::location::nearby::connections::AvailableChannels* MediumMetadata::release_available_channels() { + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::AvailableChannels* temp = available_channels_; + available_channels_ = 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 ::location::nearby::connections::AvailableChannels* MediumMetadata::unsafe_arena_release_available_channels() { + // @@protoc_insertion_point(field_release:location.nearby.connections.MediumMetadata.available_channels) + _has_bits_[0] &= ~0x00000004u; + ::location::nearby::connections::AvailableChannels* temp = available_channels_; + available_channels_ = nullptr; + return temp; +} +inline ::location::nearby::connections::AvailableChannels* MediumMetadata::_internal_mutable_available_channels() { + _has_bits_[0] |= 0x00000004u; + if (available_channels_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::AvailableChannels>(GetArenaForAllocation()); + available_channels_ = p; + } + return available_channels_; +} +inline ::location::nearby::connections::AvailableChannels* MediumMetadata::mutable_available_channels() { + ::location::nearby::connections::AvailableChannels* _msg = _internal_mutable_available_channels(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.MediumMetadata.available_channels) + return _msg; +} +inline void MediumMetadata::set_allocated_available_channels(::location::nearby::connections::AvailableChannels* available_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete available_channels_; + } + if (available_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::AvailableChannels>::GetOwningArena(available_channels); + if (message_arena != submessage_arena) { + available_channels = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, available_channels, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + available_channels_ = available_channels; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.MediumMetadata.available_channels) +} + +// optional .location.nearby.connections.WifiDirectCliUsableChannels wifi_direct_cli_usable_channels = 8; +inline bool MediumMetadata::_internal_has_wifi_direct_cli_usable_channels() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || wifi_direct_cli_usable_channels_ != nullptr); + return value; +} +inline bool MediumMetadata::has_wifi_direct_cli_usable_channels() const { + return _internal_has_wifi_direct_cli_usable_channels(); +} +inline void MediumMetadata::clear_wifi_direct_cli_usable_channels() { + if (wifi_direct_cli_usable_channels_ != nullptr) wifi_direct_cli_usable_channels_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::location::nearby::connections::WifiDirectCliUsableChannels& MediumMetadata::_internal_wifi_direct_cli_usable_channels() const { + const ::location::nearby::connections::WifiDirectCliUsableChannels* p = wifi_direct_cli_usable_channels_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_WifiDirectCliUsableChannels_default_instance_); +} +inline const ::location::nearby::connections::WifiDirectCliUsableChannels& MediumMetadata::wifi_direct_cli_usable_channels() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.wifi_direct_cli_usable_channels) + return _internal_wifi_direct_cli_usable_channels(); +} +inline void MediumMetadata::unsafe_arena_set_allocated_wifi_direct_cli_usable_channels( + ::location::nearby::connections::WifiDirectCliUsableChannels* wifi_direct_cli_usable_channels) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wifi_direct_cli_usable_channels_); + } + wifi_direct_cli_usable_channels_ = wifi_direct_cli_usable_channels; + if (wifi_direct_cli_usable_channels) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.MediumMetadata.wifi_direct_cli_usable_channels) +} +inline ::location::nearby::connections::WifiDirectCliUsableChannels* MediumMetadata::release_wifi_direct_cli_usable_channels() { + _has_bits_[0] &= ~0x00000008u; + ::location::nearby::connections::WifiDirectCliUsableChannels* temp = wifi_direct_cli_usable_channels_; + wifi_direct_cli_usable_channels_ = 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 ::location::nearby::connections::WifiDirectCliUsableChannels* MediumMetadata::unsafe_arena_release_wifi_direct_cli_usable_channels() { + // @@protoc_insertion_point(field_release:location.nearby.connections.MediumMetadata.wifi_direct_cli_usable_channels) + _has_bits_[0] &= ~0x00000008u; + ::location::nearby::connections::WifiDirectCliUsableChannels* temp = wifi_direct_cli_usable_channels_; + wifi_direct_cli_usable_channels_ = nullptr; + return temp; +} +inline ::location::nearby::connections::WifiDirectCliUsableChannels* MediumMetadata::_internal_mutable_wifi_direct_cli_usable_channels() { + _has_bits_[0] |= 0x00000008u; + if (wifi_direct_cli_usable_channels_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::WifiDirectCliUsableChannels>(GetArenaForAllocation()); + wifi_direct_cli_usable_channels_ = p; + } + return wifi_direct_cli_usable_channels_; +} +inline ::location::nearby::connections::WifiDirectCliUsableChannels* MediumMetadata::mutable_wifi_direct_cli_usable_channels() { + ::location::nearby::connections::WifiDirectCliUsableChannels* _msg = _internal_mutable_wifi_direct_cli_usable_channels(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.MediumMetadata.wifi_direct_cli_usable_channels) + return _msg; +} +inline void MediumMetadata::set_allocated_wifi_direct_cli_usable_channels(::location::nearby::connections::WifiDirectCliUsableChannels* wifi_direct_cli_usable_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete wifi_direct_cli_usable_channels_; + } + if (wifi_direct_cli_usable_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::WifiDirectCliUsableChannels>::GetOwningArena(wifi_direct_cli_usable_channels); + if (message_arena != submessage_arena) { + wifi_direct_cli_usable_channels = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wifi_direct_cli_usable_channels, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + wifi_direct_cli_usable_channels_ = wifi_direct_cli_usable_channels; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.MediumMetadata.wifi_direct_cli_usable_channels) +} + +// optional .location.nearby.connections.WifiLanUsableChannels wifi_lan_usable_channels = 9; +inline bool MediumMetadata::_internal_has_wifi_lan_usable_channels() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || wifi_lan_usable_channels_ != nullptr); + return value; +} +inline bool MediumMetadata::has_wifi_lan_usable_channels() const { + return _internal_has_wifi_lan_usable_channels(); +} +inline void MediumMetadata::clear_wifi_lan_usable_channels() { + if (wifi_lan_usable_channels_ != nullptr) wifi_lan_usable_channels_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::location::nearby::connections::WifiLanUsableChannels& MediumMetadata::_internal_wifi_lan_usable_channels() const { + const ::location::nearby::connections::WifiLanUsableChannels* p = wifi_lan_usable_channels_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_WifiLanUsableChannels_default_instance_); +} +inline const ::location::nearby::connections::WifiLanUsableChannels& MediumMetadata::wifi_lan_usable_channels() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.wifi_lan_usable_channels) + return _internal_wifi_lan_usable_channels(); +} +inline void MediumMetadata::unsafe_arena_set_allocated_wifi_lan_usable_channels( + ::location::nearby::connections::WifiLanUsableChannels* wifi_lan_usable_channels) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wifi_lan_usable_channels_); + } + wifi_lan_usable_channels_ = wifi_lan_usable_channels; + if (wifi_lan_usable_channels) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.MediumMetadata.wifi_lan_usable_channels) +} +inline ::location::nearby::connections::WifiLanUsableChannels* MediumMetadata::release_wifi_lan_usable_channels() { + _has_bits_[0] &= ~0x00000010u; + ::location::nearby::connections::WifiLanUsableChannels* temp = wifi_lan_usable_channels_; + wifi_lan_usable_channels_ = 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 ::location::nearby::connections::WifiLanUsableChannels* MediumMetadata::unsafe_arena_release_wifi_lan_usable_channels() { + // @@protoc_insertion_point(field_release:location.nearby.connections.MediumMetadata.wifi_lan_usable_channels) + _has_bits_[0] &= ~0x00000010u; + ::location::nearby::connections::WifiLanUsableChannels* temp = wifi_lan_usable_channels_; + wifi_lan_usable_channels_ = nullptr; + return temp; +} +inline ::location::nearby::connections::WifiLanUsableChannels* MediumMetadata::_internal_mutable_wifi_lan_usable_channels() { + _has_bits_[0] |= 0x00000010u; + if (wifi_lan_usable_channels_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::WifiLanUsableChannels>(GetArenaForAllocation()); + wifi_lan_usable_channels_ = p; + } + return wifi_lan_usable_channels_; +} +inline ::location::nearby::connections::WifiLanUsableChannels* MediumMetadata::mutable_wifi_lan_usable_channels() { + ::location::nearby::connections::WifiLanUsableChannels* _msg = _internal_mutable_wifi_lan_usable_channels(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.MediumMetadata.wifi_lan_usable_channels) + return _msg; +} +inline void MediumMetadata::set_allocated_wifi_lan_usable_channels(::location::nearby::connections::WifiLanUsableChannels* wifi_lan_usable_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete wifi_lan_usable_channels_; + } + if (wifi_lan_usable_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::WifiLanUsableChannels>::GetOwningArena(wifi_lan_usable_channels); + if (message_arena != submessage_arena) { + wifi_lan_usable_channels = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wifi_lan_usable_channels, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + wifi_lan_usable_channels_ = wifi_lan_usable_channels; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.MediumMetadata.wifi_lan_usable_channels) +} + +// optional .location.nearby.connections.WifiAwareUsableChannels wifi_aware_usable_channels = 10; +inline bool MediumMetadata::_internal_has_wifi_aware_usable_channels() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || wifi_aware_usable_channels_ != nullptr); + return value; +} +inline bool MediumMetadata::has_wifi_aware_usable_channels() const { + return _internal_has_wifi_aware_usable_channels(); +} +inline void MediumMetadata::clear_wifi_aware_usable_channels() { + if (wifi_aware_usable_channels_ != nullptr) wifi_aware_usable_channels_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::location::nearby::connections::WifiAwareUsableChannels& MediumMetadata::_internal_wifi_aware_usable_channels() const { + const ::location::nearby::connections::WifiAwareUsableChannels* p = wifi_aware_usable_channels_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_WifiAwareUsableChannels_default_instance_); +} +inline const ::location::nearby::connections::WifiAwareUsableChannels& MediumMetadata::wifi_aware_usable_channels() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.wifi_aware_usable_channels) + return _internal_wifi_aware_usable_channels(); +} +inline void MediumMetadata::unsafe_arena_set_allocated_wifi_aware_usable_channels( + ::location::nearby::connections::WifiAwareUsableChannels* wifi_aware_usable_channels) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wifi_aware_usable_channels_); + } + wifi_aware_usable_channels_ = wifi_aware_usable_channels; + if (wifi_aware_usable_channels) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.MediumMetadata.wifi_aware_usable_channels) +} +inline ::location::nearby::connections::WifiAwareUsableChannels* MediumMetadata::release_wifi_aware_usable_channels() { + _has_bits_[0] &= ~0x00000020u; + ::location::nearby::connections::WifiAwareUsableChannels* temp = wifi_aware_usable_channels_; + wifi_aware_usable_channels_ = 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 ::location::nearby::connections::WifiAwareUsableChannels* MediumMetadata::unsafe_arena_release_wifi_aware_usable_channels() { + // @@protoc_insertion_point(field_release:location.nearby.connections.MediumMetadata.wifi_aware_usable_channels) + _has_bits_[0] &= ~0x00000020u; + ::location::nearby::connections::WifiAwareUsableChannels* temp = wifi_aware_usable_channels_; + wifi_aware_usable_channels_ = nullptr; + return temp; +} +inline ::location::nearby::connections::WifiAwareUsableChannels* MediumMetadata::_internal_mutable_wifi_aware_usable_channels() { + _has_bits_[0] |= 0x00000020u; + if (wifi_aware_usable_channels_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::WifiAwareUsableChannels>(GetArenaForAllocation()); + wifi_aware_usable_channels_ = p; + } + return wifi_aware_usable_channels_; +} +inline ::location::nearby::connections::WifiAwareUsableChannels* MediumMetadata::mutable_wifi_aware_usable_channels() { + ::location::nearby::connections::WifiAwareUsableChannels* _msg = _internal_mutable_wifi_aware_usable_channels(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.MediumMetadata.wifi_aware_usable_channels) + return _msg; +} +inline void MediumMetadata::set_allocated_wifi_aware_usable_channels(::location::nearby::connections::WifiAwareUsableChannels* wifi_aware_usable_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete wifi_aware_usable_channels_; + } + if (wifi_aware_usable_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::WifiAwareUsableChannels>::GetOwningArena(wifi_aware_usable_channels); + if (message_arena != submessage_arena) { + wifi_aware_usable_channels = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wifi_aware_usable_channels, submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + wifi_aware_usable_channels_ = wifi_aware_usable_channels; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.MediumMetadata.wifi_aware_usable_channels) +} + +// optional .location.nearby.connections.WifiHotspotStaUsableChannels wifi_hotspot_sta_usable_channels = 11; +inline bool MediumMetadata::_internal_has_wifi_hotspot_sta_usable_channels() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || wifi_hotspot_sta_usable_channels_ != nullptr); + return value; +} +inline bool MediumMetadata::has_wifi_hotspot_sta_usable_channels() const { + return _internal_has_wifi_hotspot_sta_usable_channels(); +} +inline void MediumMetadata::clear_wifi_hotspot_sta_usable_channels() { + if (wifi_hotspot_sta_usable_channels_ != nullptr) wifi_hotspot_sta_usable_channels_->Clear(); + _has_bits_[0] &= ~0x00000040u; +} +inline const ::location::nearby::connections::WifiHotspotStaUsableChannels& MediumMetadata::_internal_wifi_hotspot_sta_usable_channels() const { + const ::location::nearby::connections::WifiHotspotStaUsableChannels* p = wifi_hotspot_sta_usable_channels_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_WifiHotspotStaUsableChannels_default_instance_); +} +inline const ::location::nearby::connections::WifiHotspotStaUsableChannels& MediumMetadata::wifi_hotspot_sta_usable_channels() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.wifi_hotspot_sta_usable_channels) + return _internal_wifi_hotspot_sta_usable_channels(); +} +inline void MediumMetadata::unsafe_arena_set_allocated_wifi_hotspot_sta_usable_channels( + ::location::nearby::connections::WifiHotspotStaUsableChannels* wifi_hotspot_sta_usable_channels) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(wifi_hotspot_sta_usable_channels_); + } + wifi_hotspot_sta_usable_channels_ = wifi_hotspot_sta_usable_channels; + if (wifi_hotspot_sta_usable_channels) { + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.MediumMetadata.wifi_hotspot_sta_usable_channels) +} +inline ::location::nearby::connections::WifiHotspotStaUsableChannels* MediumMetadata::release_wifi_hotspot_sta_usable_channels() { + _has_bits_[0] &= ~0x00000040u; + ::location::nearby::connections::WifiHotspotStaUsableChannels* temp = wifi_hotspot_sta_usable_channels_; + wifi_hotspot_sta_usable_channels_ = 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 ::location::nearby::connections::WifiHotspotStaUsableChannels* MediumMetadata::unsafe_arena_release_wifi_hotspot_sta_usable_channels() { + // @@protoc_insertion_point(field_release:location.nearby.connections.MediumMetadata.wifi_hotspot_sta_usable_channels) + _has_bits_[0] &= ~0x00000040u; + ::location::nearby::connections::WifiHotspotStaUsableChannels* temp = wifi_hotspot_sta_usable_channels_; + wifi_hotspot_sta_usable_channels_ = nullptr; + return temp; +} +inline ::location::nearby::connections::WifiHotspotStaUsableChannels* MediumMetadata::_internal_mutable_wifi_hotspot_sta_usable_channels() { + _has_bits_[0] |= 0x00000040u; + if (wifi_hotspot_sta_usable_channels_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::WifiHotspotStaUsableChannels>(GetArenaForAllocation()); + wifi_hotspot_sta_usable_channels_ = p; + } + return wifi_hotspot_sta_usable_channels_; +} +inline ::location::nearby::connections::WifiHotspotStaUsableChannels* MediumMetadata::mutable_wifi_hotspot_sta_usable_channels() { + ::location::nearby::connections::WifiHotspotStaUsableChannels* _msg = _internal_mutable_wifi_hotspot_sta_usable_channels(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.MediumMetadata.wifi_hotspot_sta_usable_channels) + return _msg; +} +inline void MediumMetadata::set_allocated_wifi_hotspot_sta_usable_channels(::location::nearby::connections::WifiHotspotStaUsableChannels* wifi_hotspot_sta_usable_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete wifi_hotspot_sta_usable_channels_; + } + if (wifi_hotspot_sta_usable_channels) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::WifiHotspotStaUsableChannels>::GetOwningArena(wifi_hotspot_sta_usable_channels); + if (message_arena != submessage_arena) { + wifi_hotspot_sta_usable_channels = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wifi_hotspot_sta_usable_channels, submessage_arena); + } + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + wifi_hotspot_sta_usable_channels_ = wifi_hotspot_sta_usable_channels; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.MediumMetadata.wifi_hotspot_sta_usable_channels) +} + +// ------------------------------------------------------------------- + +// AvailableChannels + +// repeated int32 channels = 1 [packed = true]; +inline int AvailableChannels::_internal_channels_size() const { + return channels_.size(); +} +inline int AvailableChannels::channels_size() const { + return _internal_channels_size(); +} +inline void AvailableChannels::clear_channels() { + channels_.Clear(); +} +inline int32_t AvailableChannels::_internal_channels(int index) const { + return channels_.Get(index); +} +inline int32_t AvailableChannels::channels(int index) const { + // @@protoc_insertion_point(field_get:location.nearby.connections.AvailableChannels.channels) + return _internal_channels(index); +} +inline void AvailableChannels::set_channels(int index, int32_t value) { + channels_.Set(index, value); + // @@protoc_insertion_point(field_set:location.nearby.connections.AvailableChannels.channels) +} +inline void AvailableChannels::_internal_add_channels(int32_t value) { + channels_.Add(value); +} +inline void AvailableChannels::add_channels(int32_t value) { + _internal_add_channels(value); + // @@protoc_insertion_point(field_add:location.nearby.connections.AvailableChannels.channels) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +AvailableChannels::_internal_channels() const { + return channels_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +AvailableChannels::channels() const { + // @@protoc_insertion_point(field_list:location.nearby.connections.AvailableChannels.channels) + return _internal_channels(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +AvailableChannels::_internal_mutable_channels() { + return &channels_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +AvailableChannels::mutable_channels() { + // @@protoc_insertion_point(field_mutable_list:location.nearby.connections.AvailableChannels.channels) + return _internal_mutable_channels(); +} + +// ------------------------------------------------------------------- + +// WifiDirectCliUsableChannels + +// repeated int32 channels = 1 [packed = true]; +inline int WifiDirectCliUsableChannels::_internal_channels_size() const { + return channels_.size(); +} +inline int WifiDirectCliUsableChannels::channels_size() const { + return _internal_channels_size(); +} +inline void WifiDirectCliUsableChannels::clear_channels() { + channels_.Clear(); +} +inline int32_t WifiDirectCliUsableChannels::_internal_channels(int index) const { + return channels_.Get(index); +} +inline int32_t WifiDirectCliUsableChannels::channels(int index) const { + // @@protoc_insertion_point(field_get:location.nearby.connections.WifiDirectCliUsableChannels.channels) + return _internal_channels(index); +} +inline void WifiDirectCliUsableChannels::set_channels(int index, int32_t value) { + channels_.Set(index, value); + // @@protoc_insertion_point(field_set:location.nearby.connections.WifiDirectCliUsableChannels.channels) +} +inline void WifiDirectCliUsableChannels::_internal_add_channels(int32_t value) { + channels_.Add(value); +} +inline void WifiDirectCliUsableChannels::add_channels(int32_t value) { + _internal_add_channels(value); + // @@protoc_insertion_point(field_add:location.nearby.connections.WifiDirectCliUsableChannels.channels) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +WifiDirectCliUsableChannels::_internal_channels() const { + return channels_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +WifiDirectCliUsableChannels::channels() const { + // @@protoc_insertion_point(field_list:location.nearby.connections.WifiDirectCliUsableChannels.channels) + return _internal_channels(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +WifiDirectCliUsableChannels::_internal_mutable_channels() { + return &channels_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +WifiDirectCliUsableChannels::mutable_channels() { + // @@protoc_insertion_point(field_mutable_list:location.nearby.connections.WifiDirectCliUsableChannels.channels) + return _internal_mutable_channels(); +} + +// ------------------------------------------------------------------- + +// WifiLanUsableChannels + +// repeated int32 channels = 1 [packed = true]; +inline int WifiLanUsableChannels::_internal_channels_size() const { + return channels_.size(); +} +inline int WifiLanUsableChannels::channels_size() const { + return _internal_channels_size(); +} +inline void WifiLanUsableChannels::clear_channels() { + channels_.Clear(); +} +inline int32_t WifiLanUsableChannels::_internal_channels(int index) const { + return channels_.Get(index); +} +inline int32_t WifiLanUsableChannels::channels(int index) const { + // @@protoc_insertion_point(field_get:location.nearby.connections.WifiLanUsableChannels.channels) + return _internal_channels(index); +} +inline void WifiLanUsableChannels::set_channels(int index, int32_t value) { + channels_.Set(index, value); + // @@protoc_insertion_point(field_set:location.nearby.connections.WifiLanUsableChannels.channels) +} +inline void WifiLanUsableChannels::_internal_add_channels(int32_t value) { + channels_.Add(value); +} +inline void WifiLanUsableChannels::add_channels(int32_t value) { + _internal_add_channels(value); + // @@protoc_insertion_point(field_add:location.nearby.connections.WifiLanUsableChannels.channels) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +WifiLanUsableChannels::_internal_channels() const { + return channels_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +WifiLanUsableChannels::channels() const { + // @@protoc_insertion_point(field_list:location.nearby.connections.WifiLanUsableChannels.channels) + return _internal_channels(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +WifiLanUsableChannels::_internal_mutable_channels() { + return &channels_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +WifiLanUsableChannels::mutable_channels() { + // @@protoc_insertion_point(field_mutable_list:location.nearby.connections.WifiLanUsableChannels.channels) + return _internal_mutable_channels(); +} + +// ------------------------------------------------------------------- + +// WifiAwareUsableChannels + +// repeated int32 channels = 1 [packed = true]; +inline int WifiAwareUsableChannels::_internal_channels_size() const { + return channels_.size(); +} +inline int WifiAwareUsableChannels::channels_size() const { + return _internal_channels_size(); +} +inline void WifiAwareUsableChannels::clear_channels() { + channels_.Clear(); +} +inline int32_t WifiAwareUsableChannels::_internal_channels(int index) const { + return channels_.Get(index); +} +inline int32_t WifiAwareUsableChannels::channels(int index) const { + // @@protoc_insertion_point(field_get:location.nearby.connections.WifiAwareUsableChannels.channels) + return _internal_channels(index); +} +inline void WifiAwareUsableChannels::set_channels(int index, int32_t value) { + channels_.Set(index, value); + // @@protoc_insertion_point(field_set:location.nearby.connections.WifiAwareUsableChannels.channels) +} +inline void WifiAwareUsableChannels::_internal_add_channels(int32_t value) { + channels_.Add(value); +} +inline void WifiAwareUsableChannels::add_channels(int32_t value) { + _internal_add_channels(value); + // @@protoc_insertion_point(field_add:location.nearby.connections.WifiAwareUsableChannels.channels) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +WifiAwareUsableChannels::_internal_channels() const { + return channels_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +WifiAwareUsableChannels::channels() const { + // @@protoc_insertion_point(field_list:location.nearby.connections.WifiAwareUsableChannels.channels) + return _internal_channels(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +WifiAwareUsableChannels::_internal_mutable_channels() { + return &channels_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +WifiAwareUsableChannels::mutable_channels() { + // @@protoc_insertion_point(field_mutable_list:location.nearby.connections.WifiAwareUsableChannels.channels) + return _internal_mutable_channels(); +} + +// ------------------------------------------------------------------- + +// WifiHotspotStaUsableChannels + +// repeated int32 channels = 1 [packed = true]; +inline int WifiHotspotStaUsableChannels::_internal_channels_size() const { + return channels_.size(); +} +inline int WifiHotspotStaUsableChannels::channels_size() const { + return _internal_channels_size(); +} +inline void WifiHotspotStaUsableChannels::clear_channels() { + channels_.Clear(); +} +inline int32_t WifiHotspotStaUsableChannels::_internal_channels(int index) const { + return channels_.Get(index); +} +inline int32_t WifiHotspotStaUsableChannels::channels(int index) const { + // @@protoc_insertion_point(field_get:location.nearby.connections.WifiHotspotStaUsableChannels.channels) + return _internal_channels(index); +} +inline void WifiHotspotStaUsableChannels::set_channels(int index, int32_t value) { + channels_.Set(index, value); + // @@protoc_insertion_point(field_set:location.nearby.connections.WifiHotspotStaUsableChannels.channels) +} +inline void WifiHotspotStaUsableChannels::_internal_add_channels(int32_t value) { + channels_.Add(value); +} +inline void WifiHotspotStaUsableChannels::add_channels(int32_t value) { + _internal_add_channels(value); + // @@protoc_insertion_point(field_add:location.nearby.connections.WifiHotspotStaUsableChannels.channels) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +WifiHotspotStaUsableChannels::_internal_channels() const { + return channels_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& +WifiHotspotStaUsableChannels::channels() const { + // @@protoc_insertion_point(field_list:location.nearby.connections.WifiHotspotStaUsableChannels.channels) + return _internal_channels(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +WifiHotspotStaUsableChannels::_internal_mutable_channels() { + return &channels_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* +WifiHotspotStaUsableChannels::mutable_channels() { + // @@protoc_insertion_point(field_mutable_list:location.nearby.connections.WifiHotspotStaUsableChannels.channels) + return _internal_mutable_channels(); +} + +// ------------------------------------------------------------------- + +// LocationHint + +// optional string location = 1; +inline bool LocationHint::_internal_has_location() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool LocationHint::has_location() const { + return _internal_has_location(); +} +inline void LocationHint::clear_location() { + location_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& LocationHint::location() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.LocationHint.location) + return _internal_location(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void LocationHint::set_location(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + location_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.LocationHint.location) +} +inline std::string* LocationHint::mutable_location() { + std::string* _s = _internal_mutable_location(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.LocationHint.location) + return _s; +} +inline const std::string& LocationHint::_internal_location() const { + return location_.Get(); +} +inline void LocationHint::_internal_set_location(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + location_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* LocationHint::_internal_mutable_location() { + _has_bits_[0] |= 0x00000001u; + return location_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* LocationHint::release_location() { + // @@protoc_insertion_point(field_release:location.nearby.connections.LocationHint.location) + if (!_internal_has_location()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = location_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (location_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + location_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void LocationHint::set_allocated_location(std::string* location) { + if (location != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + location_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), location, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (location_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + location_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.LocationHint.location) +} + +// optional .location.nearby.connections.LocationStandard.Format format = 2; +inline bool LocationHint::_internal_has_format() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool LocationHint::has_format() const { + return _internal_has_format(); +} +inline void LocationHint::clear_format() { + format_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::location::nearby::connections::LocationStandard_Format LocationHint::_internal_format() const { + return static_cast< ::location::nearby::connections::LocationStandard_Format >(format_); +} +inline ::location::nearby::connections::LocationStandard_Format LocationHint::format() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.LocationHint.format) + return _internal_format(); +} +inline void LocationHint::_internal_set_format(::location::nearby::connections::LocationStandard_Format value) { + assert(::location::nearby::connections::LocationStandard_Format_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + format_ = value; +} +inline void LocationHint::set_format(::location::nearby::connections::LocationStandard_Format value) { + _internal_set_format(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.LocationHint.format) +} + +// ------------------------------------------------------------------- + +// LocationStandard + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace connections +} // namespace nearby +} // namespace location + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::location::nearby::connections::OfflineFrame_Version> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::V1Frame_FrameType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::ConnectionRequestFrame_Medium> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::ConnectionResponseFrame_ResponseStatus> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::PayloadTransferFrame_PayloadHeader_PayloadType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::PayloadTransferFrame_PayloadChunk_Flags> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::PayloadTransferFrame_ControlMessage_EventType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::PayloadTransferFrame_PacketType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::LocationStandard_Format> : ::std::true_type {}; + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto