From 78dcf8e7eace22d0b836cc344451ada11287e7eb Mon Sep 17 00:00:00 2001 From: Anay Wadhera Date: Wed, 19 Nov 2025 14:52:52 +0000 Subject: [PATCH] Update compiled protos --- .../proto/offline_wire_formats.pb.cc | 241 +- .../proto/offline_wire_formats.pb.h | 306 +- .../proto/analytics/connections_log.pb.cc | 826 +- .../proto/analytics/connections_log.pb.h | 836 +- compiled_proto/proto/connections_enums.pb.cc | 1237 +-- compiled_proto/proto/connections_enums.pb.h | 72 +- compiled_proto/proto/sharing_enums.pb.cc | 653 +- compiled_proto/proto/sharing_enums.pb.h | 114 +- .../proto/analytics/nearby_sharing_log.pb.cc | 6740 +++++++++++++- .../proto/analytics/nearby_sharing_log.pb.h | 8249 ++++++++++++++++- gen_proto.sh | 4 +- 11 files changed, 18000 insertions(+), 1278 deletions(-) diff --git a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc index 5eddcdab..23d5cf27 100644 --- a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc +++ b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc @@ -243,6 +243,8 @@ constexpr BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials , password_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , gateway_(nullptr) , ip_v6_address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , service_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , pin_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , port_(0) , frequency_(0){} struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentialsDefaultTypeInternal { @@ -480,7 +482,9 @@ struct AutoReconnectFrameDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AutoReconnectFrameDefaultTypeInternal _AutoReconnectFrame_default_instance_; constexpr MediumMetadata::MediumMetadata( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : bssid_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + : supported_wifi_direct_auth_types_() + , _supported_wifi_direct_auth_types_cached_byte_size_(0) + , 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) @@ -1778,6 +1782,69 @@ constexpr AutoReconnectFrame_EventType AutoReconnectFrame::EventType_MIN; constexpr AutoReconnectFrame_EventType AutoReconnectFrame::EventType_MAX; constexpr int AutoReconnectFrame::EventType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool MediumMetadata_WifiDirectAuthType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed MediumMetadata_WifiDirectAuthType_strings[3] = {}; + +static const char MediumMetadata_WifiDirectAuthType_names[] = + "WIFI_DIRECT_TYPE_UNKNOWN" + "WIFI_DIRECT_WITH_PASSWORD" + "WIFI_DIRECT_WITH_PIN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MediumMetadata_WifiDirectAuthType_entries[] = { + { {MediumMetadata_WifiDirectAuthType_names + 0, 24}, 0 }, + { {MediumMetadata_WifiDirectAuthType_names + 24, 25}, 1 }, + { {MediumMetadata_WifiDirectAuthType_names + 49, 20}, 2 }, +}; + +static const int MediumMetadata_WifiDirectAuthType_entries_by_number[] = { + 0, // 0 -> WIFI_DIRECT_TYPE_UNKNOWN + 1, // 1 -> WIFI_DIRECT_WITH_PASSWORD + 2, // 2 -> WIFI_DIRECT_WITH_PIN +}; + +const std::string& MediumMetadata_WifiDirectAuthType_Name( + MediumMetadata_WifiDirectAuthType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + MediumMetadata_WifiDirectAuthType_entries, + MediumMetadata_WifiDirectAuthType_entries_by_number, + 3, MediumMetadata_WifiDirectAuthType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + MediumMetadata_WifiDirectAuthType_entries, + MediumMetadata_WifiDirectAuthType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + MediumMetadata_WifiDirectAuthType_strings[idx].get(); +} +bool MediumMetadata_WifiDirectAuthType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediumMetadata_WifiDirectAuthType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + MediumMetadata_WifiDirectAuthType_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 MediumMetadata_WifiDirectAuthType MediumMetadata::WIFI_DIRECT_TYPE_UNKNOWN; +constexpr MediumMetadata_WifiDirectAuthType MediumMetadata::WIFI_DIRECT_WITH_PASSWORD; +constexpr MediumMetadata_WifiDirectAuthType MediumMetadata::WIFI_DIRECT_WITH_PIN; +constexpr MediumMetadata_WifiDirectAuthType MediumMetadata::WifiDirectAuthType_MIN; +constexpr MediumMetadata_WifiDirectAuthType MediumMetadata::WifiDirectAuthType_MAX; +constexpr int MediumMetadata::WifiDirectAuthType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) bool LocationStandard_Format_IsValid(int value) { switch (value) { case 0: @@ -7226,10 +7293,10 @@ class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_I (*has_bits)[0] |= 2u; } static void set_has_port(HasBits* has_bits) { - (*has_bits)[0] |= 16u; + (*has_bits)[0] |= 64u; } static void set_has_frequency(HasBits* has_bits) { - (*has_bits)[0] |= 32u; + (*has_bits)[0] |= 128u; } static void set_has_gateway(HasBits* has_bits) { (*has_bits)[0] |= 4u; @@ -7237,6 +7304,12 @@ class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_I static void set_has_ip_v6_address(HasBits* has_bits) { (*has_bits)[0] |= 8u; } + static void set_has_service_name(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_pin(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } }; const ::PROTOBUF_NAMESPACE_ID::internal::LazyString BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_i_give_permission_to_break_this_code_default_gateway_{{{"0.0.0.0", 7}}, {nullptr}}; @@ -7282,6 +7355,22 @@ BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::Bandwidt ip_v6_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_ip_v6_address(), GetArenaForAllocation()); } + 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()); + } + pin_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + pin_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_pin()) { + pin_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pin(), + GetArenaForAllocation()); + } ::memcpy(&port_, &from.port_, static_cast(reinterpret_cast(&frequency_) - reinterpret_cast(&port_)) + sizeof(frequency_)); @@ -7302,6 +7391,14 @@ ip_v6_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStri #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING ip_v6_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +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 +pin_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + pin_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&port_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&frequency_) - @@ -7321,6 +7418,8 @@ inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentia password_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); gateway_.DestroyNoArena(nullptr); ip_v6_address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + service_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + pin_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::ArenaDtor(void* object) { @@ -7340,7 +7439,7 @@ void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::Cle (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { ssid_.ClearNonDefaultToEmpty(); } @@ -7353,8 +7452,14 @@ void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::Cle if (cached_has_bits & 0x00000008u) { ip_v6_address_.ClearNonDefaultToEmpty(); } + if (cached_has_bits & 0x00000010u) { + service_name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000020u) { + pin_.ClearNonDefaultToEmpty(); + } } - if (cached_has_bits & 0x00000030u) { + if (cached_has_bits & 0x000000c0u) { ::memset(&port_, 0, static_cast( reinterpret_cast(&frequency_) - reinterpret_cast(&port_)) + sizeof(frequency_)); @@ -7424,6 +7529,24 @@ const char* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentia } else goto handle_unusual; continue; + // optional string service_name = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_service_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string pin = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_pin(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -7468,13 +7591,13 @@ uint8_t* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials: } // optional int32 port = 3; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_port(), target); } // optional int32 frequency = 4; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_frequency(), target); } @@ -7491,6 +7614,18 @@ uint8_t* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials: 6, this->_internal_ip_v6_address(), target); } + // optional string service_name = 7; + if (cached_has_bits & 0x00000010u) { + target = stream->WriteStringMaybeAliased( + 7, this->_internal_service_name(), target); + } + + // optional string pin = 8; + if (cached_has_bits & 0x00000020u) { + target = stream->WriteStringMaybeAliased( + 8, this->_internal_pin(), 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); @@ -7508,7 +7643,7 @@ size_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::B (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x000000ffu) { // optional string ssid = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -7537,13 +7672,27 @@ size_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::B this->_internal_ip_v6_address()); } - // optional int32 port = 3; + // optional string service_name = 7; if (cached_has_bits & 0x00000010u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_service_name()); + } + + // optional string pin = 8; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_pin()); + } + + // optional int32 port = 3; + if (cached_has_bits & 0x00000040u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_port()); } // optional int32 frequency = 4; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000080u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_frequency()); } @@ -7569,7 +7718,7 @@ void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::Mer (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_ssid(from._internal_ssid()); } @@ -7583,9 +7732,15 @@ void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::Mer _internal_set_ip_v6_address(from._internal_ip_v6_address()); } if (cached_has_bits & 0x00000010u) { - port_ = from.port_; + _internal_set_service_name(from._internal_service_name()); } if (cached_has_bits & 0x00000020u) { + _internal_set_pin(from._internal_pin()); + } + if (cached_has_bits & 0x00000040u) { + port_ = from.port_; + } + if (cached_has_bits & 0x00000080u) { frequency_ = from.frequency_; } _has_bits_[0] |= cached_has_bits; @@ -7630,6 +7785,16 @@ void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::Int &ip_v6_address_, lhs_arena, &other->ip_v6_address_, rhs_arena ); + ::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(), + &pin_, lhs_arena, + &other->pin_, rhs_arena + ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials, frequency_) + sizeof(BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::frequency_) @@ -12077,7 +12242,8 @@ MediumMetadata::_Internal::medium_role(const MediumMetadata* msg) { } MediumMetadata::MediumMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + supported_wifi_direct_auth_types_(arena) { SharedCtor(); if (!is_message_owned) { RegisterArenaDtor(arena); @@ -12086,7 +12252,8 @@ MediumMetadata::MediumMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, } MediumMetadata::MediumMetadata(const MediumMetadata& from) : ::PROTOBUF_NAMESPACE_ID::MessageLite(), - _has_bits_(from._has_bits_) { + _has_bits_(from._has_bits_), + supported_wifi_direct_auth_types_(from.supported_wifi_direct_auth_types_) { _internal_metadata_.MergeFrom(from._internal_metadata_); bssid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING @@ -12191,6 +12358,7 @@ void MediumMetadata::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + supported_wifi_direct_auth_types_.Clear(); cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { @@ -12341,6 +12509,22 @@ const char* MediumMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE } else goto handle_unusual; continue; + // repeated .location.nearby.connections.MediumMetadata.WifiDirectAuthType supported_wifi_direct_auth_types = 13 [packed = true]; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser(_internal_mutable_supported_wifi_direct_auth_types(), ptr, ctx, ::location::nearby::connections::MediumMetadata_WifiDirectAuthType_IsValid, &_internal_metadata_, 13); + CHK_(ptr); + } else if (static_cast(tag) == 104) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::MediumMetadata_WifiDirectAuthType_IsValid(val))) { + _internal_add_supported_wifi_direct_auth_types(static_cast<::location::nearby::connections::MediumMetadata_WifiDirectAuthType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -12456,6 +12640,15 @@ uint8_t* MediumMetadata::_InternalSerialize( 12, _Internal::medium_role(this), target, stream); } + // repeated .location.nearby.connections.MediumMetadata.WifiDirectAuthType supported_wifi_direct_auth_types = 13 [packed = true]; + { + int byte_size = _supported_wifi_direct_auth_types_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteEnumPacked( + 13, supported_wifi_direct_auth_types_, 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); @@ -12472,6 +12665,24 @@ size_t MediumMetadata::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + // repeated .location.nearby.connections.MediumMetadata.WifiDirectAuthType supported_wifi_direct_auth_types = 13 [packed = true]; + { + size_t data_size = 0; + unsigned int count = static_cast(this->_internal_supported_wifi_direct_auth_types_size());for (unsigned int i = 0; i < count; i++) { + data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize( + this->_internal_supported_wifi_direct_auth_types(static_cast(i))); + } + 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); + _supported_wifi_direct_auth_types_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + cached_has_bits = _has_bits_[0]; if (cached_has_bits & 0x000000ffu) { // optional string bssid = 2; @@ -12573,6 +12784,7 @@ void MediumMetadata::MergeFrom(const MediumMetadata& from) { uint32_t cached_has_bits = 0; (void) cached_has_bits; + supported_wifi_direct_auth_types_.MergeFrom(from.supported_wifi_direct_auth_types_); cached_has_bits = from._has_bits_[0]; if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { @@ -12635,6 +12847,7 @@ void MediumMetadata::InternalSwap(MediumMetadata* other) { auto* rhs_arena = other->GetArenaForAllocation(); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); + supported_wifi_direct_auth_types_.InternalSwap(&other->supported_wifi_direct_auth_types_); ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &bssid_, lhs_arena, diff --git a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h index 37d767ad..89c74a22 100644 --- a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h +++ b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h @@ -13,7 +13,7 @@ #error incompatible with your Protocol Buffer headers. Please update #error your headers. #endif -#if 3019000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019005 < 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. @@ -556,6 +556,26 @@ inline const std::string& AutoReconnectFrame_EventType_Name(T enum_t_value) { } bool AutoReconnectFrame_EventType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutoReconnectFrame_EventType* value); +enum MediumMetadata_WifiDirectAuthType : int { + MediumMetadata_WifiDirectAuthType_WIFI_DIRECT_TYPE_UNKNOWN = 0, + MediumMetadata_WifiDirectAuthType_WIFI_DIRECT_WITH_PASSWORD = 1, + MediumMetadata_WifiDirectAuthType_WIFI_DIRECT_WITH_PIN = 2 +}; +bool MediumMetadata_WifiDirectAuthType_IsValid(int value); +constexpr MediumMetadata_WifiDirectAuthType MediumMetadata_WifiDirectAuthType_WifiDirectAuthType_MIN = MediumMetadata_WifiDirectAuthType_WIFI_DIRECT_TYPE_UNKNOWN; +constexpr MediumMetadata_WifiDirectAuthType MediumMetadata_WifiDirectAuthType_WifiDirectAuthType_MAX = MediumMetadata_WifiDirectAuthType_WIFI_DIRECT_WITH_PIN; +constexpr int MediumMetadata_WifiDirectAuthType_WifiDirectAuthType_ARRAYSIZE = MediumMetadata_WifiDirectAuthType_WifiDirectAuthType_MAX + 1; + +const std::string& MediumMetadata_WifiDirectAuthType_Name(MediumMetadata_WifiDirectAuthType value); +template +inline const std::string& MediumMetadata_WifiDirectAuthType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function MediumMetadata_WifiDirectAuthType_Name."); + return MediumMetadata_WifiDirectAuthType_Name(static_cast(enum_t_value)); +} +bool MediumMetadata_WifiDirectAuthType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MediumMetadata_WifiDirectAuthType* value); enum LocationStandard_Format : int { LocationStandard_Format_UNKNOWN = 0, LocationStandard_Format_E164_CALLING = 1, @@ -4028,6 +4048,8 @@ class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials fin kPasswordFieldNumber = 2, kGatewayFieldNumber = 5, kIpV6AddressFieldNumber = 6, + kServiceNameFieldNumber = 7, + kPinFieldNumber = 8, kPortFieldNumber = 3, kFrequencyFieldNumber = 4, }; @@ -4103,6 +4125,42 @@ class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials fin std::string* _internal_mutable_ip_v6_address(); public: + // optional string service_name = 7; + 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 pin = 8; + bool has_pin() const; + private: + bool _internal_has_pin() const; + public: + void clear_pin(); + const std::string& pin() const; + template + void set_pin(ArgT0&& arg0, ArgT... args); + std::string* mutable_pin(); + PROTOBUF_NODISCARD std::string* release_pin(); + void set_allocated_pin(std::string* pin); + private: + const std::string& _internal_pin() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_pin(const std::string& value); + std::string* _internal_mutable_pin(); + public: + // optional int32 port = 3; bool has_port() const; private: @@ -4143,6 +4201,8 @@ class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials fin static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_gateway_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gateway_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_v6_address_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pin_; int32_t port_; int32_t frequency_; friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; @@ -7266,9 +7326,38 @@ class MediumMetadata final : // nested types ---------------------------------------------------- + typedef MediumMetadata_WifiDirectAuthType WifiDirectAuthType; + static constexpr WifiDirectAuthType WIFI_DIRECT_TYPE_UNKNOWN = + MediumMetadata_WifiDirectAuthType_WIFI_DIRECT_TYPE_UNKNOWN; + static constexpr WifiDirectAuthType WIFI_DIRECT_WITH_PASSWORD = + MediumMetadata_WifiDirectAuthType_WIFI_DIRECT_WITH_PASSWORD; + static constexpr WifiDirectAuthType WIFI_DIRECT_WITH_PIN = + MediumMetadata_WifiDirectAuthType_WIFI_DIRECT_WITH_PIN; + static inline bool WifiDirectAuthType_IsValid(int value) { + return MediumMetadata_WifiDirectAuthType_IsValid(value); + } + static constexpr WifiDirectAuthType WifiDirectAuthType_MIN = + MediumMetadata_WifiDirectAuthType_WifiDirectAuthType_MIN; + static constexpr WifiDirectAuthType WifiDirectAuthType_MAX = + MediumMetadata_WifiDirectAuthType_WifiDirectAuthType_MAX; + static constexpr int WifiDirectAuthType_ARRAYSIZE = + MediumMetadata_WifiDirectAuthType_WifiDirectAuthType_ARRAYSIZE; + template + static inline const std::string& WifiDirectAuthType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function WifiDirectAuthType_Name."); + return MediumMetadata_WifiDirectAuthType_Name(enum_t_value); + } + static inline bool WifiDirectAuthType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + WifiDirectAuthType* value) { + return MediumMetadata_WifiDirectAuthType_Parse(name, value); + } + // accessors ------------------------------------------------------- enum : int { + kSupportedWifiDirectAuthTypesFieldNumber = 13, kBssidFieldNumber = 2, kIpAddressFieldNumber = 3, kAvailableChannelsFieldNumber = 7, @@ -7282,6 +7371,23 @@ class MediumMetadata final : kMobileRadioFieldNumber = 5, kApFrequencyFieldNumber = 6, }; + // repeated .location.nearby.connections.MediumMetadata.WifiDirectAuthType supported_wifi_direct_auth_types = 13 [packed = true]; + int supported_wifi_direct_auth_types_size() const; + private: + int _internal_supported_wifi_direct_auth_types_size() const; + public: + void clear_supported_wifi_direct_auth_types(); + private: + ::location::nearby::connections::MediumMetadata_WifiDirectAuthType _internal_supported_wifi_direct_auth_types(int index) const; + void _internal_add_supported_wifi_direct_auth_types(::location::nearby::connections::MediumMetadata_WifiDirectAuthType value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_supported_wifi_direct_auth_types(); + public: + ::location::nearby::connections::MediumMetadata_WifiDirectAuthType supported_wifi_direct_auth_types(int index) const; + void set_supported_wifi_direct_auth_types(int index, ::location::nearby::connections::MediumMetadata_WifiDirectAuthType value); + void add_supported_wifi_direct_auth_types(::location::nearby::connections::MediumMetadata_WifiDirectAuthType value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField& supported_wifi_direct_auth_types() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_supported_wifi_direct_auth_types(); + // optional string bssid = 2; bool has_bssid() const; private: @@ -7487,6 +7593,8 @@ class MediumMetadata final : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField supported_wifi_direct_auth_types_; + mutable std::atomic _supported_wifi_direct_auth_types_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bssid_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ip_address_; ::location::nearby::connections::AvailableChannels* available_channels_; @@ -13931,7 +14039,7 @@ inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentia // optional int32 port = 3; inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_has_port() const { - bool value = (_has_bits_[0] & 0x00000010u) != 0; + bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::has_port() const { @@ -13939,7 +14047,7 @@ inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentia } inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::clear_port() { port_ = 0; - _has_bits_[0] &= ~0x00000010u; + _has_bits_[0] &= ~0x00000040u; } inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_port() const { return port_; @@ -13949,7 +14057,7 @@ inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCreden return _internal_port(); } inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_set_port(int32_t value) { - _has_bits_[0] |= 0x00000010u; + _has_bits_[0] |= 0x00000040u; port_ = value; } inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_port(int32_t value) { @@ -13959,7 +14067,7 @@ inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentia // optional int32 frequency = 4; inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_has_frequency() const { - bool value = (_has_bits_[0] & 0x00000020u) != 0; + bool value = (_has_bits_[0] & 0x00000080u) != 0; return value; } inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::has_frequency() const { @@ -13967,7 +14075,7 @@ inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentia } inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::clear_frequency() { frequency_ = 0; - _has_bits_[0] &= ~0x00000020u; + _has_bits_[0] &= ~0x00000080u; } inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_frequency() const { return frequency_; @@ -13977,7 +14085,7 @@ inline int32_t BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCreden return _internal_frequency(); } inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_set_frequency(int32_t value) { - _has_bits_[0] |= 0x00000020u; + _has_bits_[0] |= 0x00000080u; frequency_ = value; } inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_frequency(int32_t value) { @@ -14114,6 +14222,144 @@ inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentia // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.ip_v6_address) } +// optional string service_name = 7; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_has_service_name() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::has_service_name() const { + return _internal_has_service_name(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::clear_service_name() { + service_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::service_name() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.service_name) + return _internal_service_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_service_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000010u; + service_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.service_name) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::mutable_service_name() { + std::string* _s = _internal_mutable_service_name(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.service_name) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_service_name() const { + return service_name_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_set_service_name(const std::string& value) { + _has_bits_[0] |= 0x00000010u; + service_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_mutable_service_name() { + _has_bits_[0] |= 0x00000010u; + return service_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::release_service_name() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.service_name) + if (!_internal_has_service_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + 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_WifiDirectCredentials::set_allocated_service_name(std::string* service_name) { + if (service_name != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + 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.WifiDirectCredentials.service_name) +} + +// optional string pin = 8; +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_has_pin() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::has_pin() const { + return _internal_has_pin(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::clear_pin() { + pin_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000020u; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::pin() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.pin) + return _internal_pin(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_pin(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000020u; + pin_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.pin) +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::mutable_pin() { + std::string* _s = _internal_mutable_pin(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.pin) + return _s; +} +inline const std::string& BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_pin() const { + return pin_.Get(); +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_set_pin(const std::string& value) { + _has_bits_[0] |= 0x00000020u; + pin_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::_internal_mutable_pin() { + _has_bits_[0] |= 0x00000020u; + return pin_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::release_pin() { + // @@protoc_insertion_point(field_release:location.nearby.connections.BandwidthUpgradeNegotiationFrame.UpgradePathInfo.WifiDirectCredentials.pin) + if (!_internal_has_pin()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000020u; + auto* p = pin_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (pin_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + pin_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials::set_allocated_pin(std::string* pin) { + if (pin != nullptr) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + pin_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pin, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (pin_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + pin_.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.pin) +} + // ------------------------------------------------------------------- // BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WebRtcCredentials @@ -17492,6 +17738,51 @@ inline void MediumMetadata::set_allocated_medium_role(::location::nearby::connec // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.MediumMetadata.medium_role) } +// repeated .location.nearby.connections.MediumMetadata.WifiDirectAuthType supported_wifi_direct_auth_types = 13 [packed = true]; +inline int MediumMetadata::_internal_supported_wifi_direct_auth_types_size() const { + return supported_wifi_direct_auth_types_.size(); +} +inline int MediumMetadata::supported_wifi_direct_auth_types_size() const { + return _internal_supported_wifi_direct_auth_types_size(); +} +inline void MediumMetadata::clear_supported_wifi_direct_auth_types() { + supported_wifi_direct_auth_types_.Clear(); +} +inline ::location::nearby::connections::MediumMetadata_WifiDirectAuthType MediumMetadata::_internal_supported_wifi_direct_auth_types(int index) const { + return static_cast< ::location::nearby::connections::MediumMetadata_WifiDirectAuthType >(supported_wifi_direct_auth_types_.Get(index)); +} +inline ::location::nearby::connections::MediumMetadata_WifiDirectAuthType MediumMetadata::supported_wifi_direct_auth_types(int index) const { + // @@protoc_insertion_point(field_get:location.nearby.connections.MediumMetadata.supported_wifi_direct_auth_types) + return _internal_supported_wifi_direct_auth_types(index); +} +inline void MediumMetadata::set_supported_wifi_direct_auth_types(int index, ::location::nearby::connections::MediumMetadata_WifiDirectAuthType value) { + assert(::location::nearby::connections::MediumMetadata_WifiDirectAuthType_IsValid(value)); + supported_wifi_direct_auth_types_.Set(index, value); + // @@protoc_insertion_point(field_set:location.nearby.connections.MediumMetadata.supported_wifi_direct_auth_types) +} +inline void MediumMetadata::_internal_add_supported_wifi_direct_auth_types(::location::nearby::connections::MediumMetadata_WifiDirectAuthType value) { + assert(::location::nearby::connections::MediumMetadata_WifiDirectAuthType_IsValid(value)); + supported_wifi_direct_auth_types_.Add(value); +} +inline void MediumMetadata::add_supported_wifi_direct_auth_types(::location::nearby::connections::MediumMetadata_WifiDirectAuthType value) { + _internal_add_supported_wifi_direct_auth_types(value); + // @@protoc_insertion_point(field_add:location.nearby.connections.MediumMetadata.supported_wifi_direct_auth_types) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& +MediumMetadata::supported_wifi_direct_auth_types() const { + // @@protoc_insertion_point(field_list:location.nearby.connections.MediumMetadata.supported_wifi_direct_auth_types) + return supported_wifi_direct_auth_types_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +MediumMetadata::_internal_mutable_supported_wifi_direct_auth_types() { + return &supported_wifi_direct_auth_types_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* +MediumMetadata::mutable_supported_wifi_direct_auth_types() { + // @@protoc_insertion_point(field_mutable_list:location.nearby.connections.MediumMetadata.supported_wifi_direct_auth_types) + return _internal_mutable_supported_wifi_direct_auth_types(); +} + // ------------------------------------------------------------------- // AvailableChannels @@ -18967,6 +19258,7 @@ template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgr template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::AutoResumeFrame_EventType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::AutoReconnectFrame_EventType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::MediumMetadata_WifiDirectAuthType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::LocationStandard_Format> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::OsInfo_OsType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::PresenceDevice_DeviceType> : ::std::true_type {}; diff --git a/compiled_proto/internal/proto/analytics/connections_log.pb.cc b/compiled_proto/internal/proto/analytics/connections_log.pb.cc index 2ebdd90e..55de19c8 100644 --- a/compiled_proto/internal/proto/analytics/connections_log.pb.cc +++ b/compiled_proto/internal/proto/analytics/connections_log.pb.cc @@ -101,6 +101,8 @@ constexpr ConnectionsLog_DiscoveryPhase::ConnectionsLog_DiscoveryPhase( , stop_reason_(0) , device_type_(0) + + , supported_service_(0) {} struct ConnectionsLog_DiscoveryPhaseDefaultTypeInternal { constexpr ConnectionsLog_DiscoveryPhaseDefaultTypeInternal() @@ -172,6 +174,8 @@ constexpr ConnectionsLog_AdvertisingPhase::ConnectionsLog_AdvertisingPhase( , stop_reason_(0) , device_type_(0) + + , supported_service_(0) {} struct ConnectionsLog_AdvertisingPhaseDefaultTypeInternal { constexpr ConnectionsLog_AdvertisingPhaseDefaultTypeInternal() @@ -218,6 +222,10 @@ constexpr ConnectionsLog_ConnectionAttempt::ConnectionsLog_ConnectionAttempt( , connection_mode_(0) , device_type_(0) + + , wifi_connection_latency_millis_(int64_t{0}) + , device_attestation_latency_millis_(int64_t{0}) + , supported_service_(0) {} struct ConnectionsLog_ConnectionAttemptDefaultTypeInternal { constexpr ConnectionsLog_ConnectionAttemptDefaultTypeInternal() @@ -277,6 +285,8 @@ constexpr ConnectionsLog_EstablishedConnection::ConnectionsLog_EstablishedConnec , safe_disconnection_result_(0) , device_type_(0) + + , supported_service_(0) {} struct ConnectionsLog_EstablishedConnectionDefaultTypeInternal { constexpr ConnectionsLog_EstablishedConnectionDefaultTypeInternal() @@ -287,9 +297,27 @@ struct ConnectionsLog_EstablishedConnectionDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionsLog_EstablishedConnectionDefaultTypeInternal _ConnectionsLog_EstablishedConnection_default_instance_; +constexpr ConnectionsLog_DctPayloadTransferStats::ConnectionsLog_DctPayloadTransferStats( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(0) + + , num_parts_success_(0) + , is_multipart_(false) + , is_resumption_(false) + , num_parts_failure_(0){} +struct ConnectionsLog_DctPayloadTransferStatsDefaultTypeInternal { + constexpr ConnectionsLog_DctPayloadTransferStatsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ConnectionsLog_DctPayloadTransferStatsDefaultTypeInternal() {} + union { + ConnectionsLog_DctPayloadTransferStats _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionsLog_DctPayloadTransferStatsDefaultTypeInternal _ConnectionsLog_DctPayloadTransferStats_default_instance_; constexpr ConnectionsLog_Payload::ConnectionsLog_Payload( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : operation_result_(nullptr) + , dct_payload_transfer_stats_(nullptr) , duration_millis_(int64_t{0}) , total_size_bytes_(int64_t{0}) , type_(0) @@ -326,6 +354,8 @@ constexpr ConnectionsLog_BandwidthUpgradeAttempt::ConnectionsLog_BandwidthUpgrad , error_stage_(0) , device_type_(0) + + , supported_service_(0) {} struct ConnectionsLog_BandwidthUpgradeAttemptDefaultTypeInternal { constexpr ConnectionsLog_BandwidthUpgradeAttemptDefaultTypeInternal() @@ -2145,6 +2175,9 @@ class ConnectionsLog_DiscoveryPhase::_Internal { static void set_has_device_type(HasBits* has_bits) { (*has_bits)[0] |= 16u; } + static void set_has_supported_service(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } }; const ::location::nearby::analytics::proto::ConnectionsLog_DiscoveryMetadata& @@ -2180,16 +2213,16 @@ ConnectionsLog_DiscoveryPhase::ConnectionsLog_DiscoveryPhase(const ConnectionsLo discovery_metadata_ = nullptr; } ::memcpy(&duration_millis_, &from.duration_millis_, - static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&duration_millis_)) + sizeof(device_type_)); + static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&duration_millis_)) + sizeof(supported_service_)); // @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.DiscoveryPhase) } inline void ConnectionsLog_DiscoveryPhase::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&discovery_metadata_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&discovery_metadata_)) + sizeof(device_type_)); + 0, static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&discovery_metadata_)) + sizeof(supported_service_)); } ConnectionsLog_DiscoveryPhase::~ConnectionsLog_DiscoveryPhase() { @@ -2230,10 +2263,10 @@ void ConnectionsLog_DiscoveryPhase::Clear() { GOOGLE_DCHECK(discovery_metadata_ != nullptr); discovery_metadata_->Clear(); } - if (cached_has_bits & 0x0000001eu) { + if (cached_has_bits & 0x0000003eu) { ::memset(&duration_millis_, 0, static_cast( - reinterpret_cast(&device_type_) - - reinterpret_cast(&duration_millis_)) + sizeof(device_type_)); + reinterpret_cast(&supported_service_) - + reinterpret_cast(&duration_millis_)) + sizeof(supported_service_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -2371,6 +2404,19 @@ const char* ConnectionsLog_DiscoveryPhase::_InternalParse(const char* ptr, ::PRO } else goto handle_unusual; continue; + // optional .location.nearby.proto.connections.SupportedService supported_service = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::connections::SupportedService_IsValid(val))) { + _internal_set_supported_service(static_cast<::location::nearby::proto::connections::SupportedService>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -2475,6 +2521,13 @@ uint8_t* ConnectionsLog_DiscoveryPhase::_InternalSerialize( 10, this->_internal_device_type(), target); } + // optional .location.nearby.proto.connections.SupportedService supported_service = 11; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 11, this->_internal_supported_service(), 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); @@ -2530,7 +2583,7 @@ size_t ConnectionsLog_DiscoveryPhase::ByteSizeLong() const { } cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x0000003fu) { // optional .location.nearby.analytics.proto.ConnectionsLog.DiscoveryMetadata discovery_metadata = 7; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -2560,6 +2613,12 @@ size_t ConnectionsLog_DiscoveryPhase::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_device_type()); } + // optional .location.nearby.proto.connections.SupportedService supported_service = 11; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_supported_service()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -2587,7 +2646,7 @@ void ConnectionsLog_DiscoveryPhase::MergeFrom(const ConnectionsLog_DiscoveryPhas uwb_ranging_.MergeFrom(from.uwb_ranging_); adv_dis_result_.MergeFrom(from.adv_dis_result_); cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_discovery_metadata()->::location::nearby::analytics::proto::ConnectionsLog_DiscoveryMetadata::MergeFrom(from._internal_discovery_metadata()); } @@ -2603,6 +2662,9 @@ void ConnectionsLog_DiscoveryPhase::MergeFrom(const ConnectionsLog_DiscoveryPhas if (cached_has_bits & 0x00000010u) { device_type_ = from.device_type_; } + if (cached_has_bits & 0x00000020u) { + supported_service_ = from.supported_service_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -2629,8 +2691,8 @@ void ConnectionsLog_DiscoveryPhase::InternalSwap(ConnectionsLog_DiscoveryPhase* uwb_ranging_.InternalSwap(&other->uwb_ranging_); adv_dis_result_.InternalSwap(&other->adv_dis_result_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ConnectionsLog_DiscoveryPhase, device_type_) - + sizeof(ConnectionsLog_DiscoveryPhase::device_type_) + PROTOBUF_FIELD_OFFSET(ConnectionsLog_DiscoveryPhase, supported_service_) + + sizeof(ConnectionsLog_DiscoveryPhase::supported_service_) - PROTOBUF_FIELD_OFFSET(ConnectionsLog_DiscoveryPhase, discovery_metadata_)>( reinterpret_cast(&discovery_metadata_), reinterpret_cast(&other->discovery_metadata_)); @@ -3647,6 +3709,9 @@ class ConnectionsLog_AdvertisingPhase::_Internal { static void set_has_device_type(HasBits* has_bits) { (*has_bits)[0] |= 16u; } + static void set_has_supported_service(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } }; const ::location::nearby::analytics::proto::ConnectionsLog_AdvertisingMetadata& @@ -3678,16 +3743,16 @@ ConnectionsLog_AdvertisingPhase::ConnectionsLog_AdvertisingPhase(const Connectio advertising_metadata_ = nullptr; } ::memcpy(&duration_millis_, &from.duration_millis_, - static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&duration_millis_)) + sizeof(device_type_)); + static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&duration_millis_)) + sizeof(supported_service_)); // @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.AdvertisingPhase) } inline void ConnectionsLog_AdvertisingPhase::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&advertising_metadata_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&advertising_metadata_)) + sizeof(device_type_)); + 0, static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&advertising_metadata_)) + sizeof(supported_service_)); } ConnectionsLog_AdvertisingPhase::~ConnectionsLog_AdvertisingPhase() { @@ -3726,10 +3791,10 @@ void ConnectionsLog_AdvertisingPhase::Clear() { GOOGLE_DCHECK(advertising_metadata_ != nullptr); advertising_metadata_->Clear(); } - if (cached_has_bits & 0x0000001eu) { + if (cached_has_bits & 0x0000003eu) { ::memset(&duration_millis_, 0, static_cast( - reinterpret_cast(&device_type_) - - reinterpret_cast(&duration_millis_)) + sizeof(device_type_)); + reinterpret_cast(&supported_service_) - + reinterpret_cast(&duration_millis_)) + sizeof(supported_service_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -3841,6 +3906,19 @@ const char* ConnectionsLog_AdvertisingPhase::_InternalParse(const char* ptr, ::P } else goto handle_unusual; continue; + // optional .location.nearby.proto.connections.SupportedService supported_service = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::connections::SupportedService_IsValid(val))) { + _internal_set_supported_service(static_cast<::location::nearby::proto::connections::SupportedService>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(9, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -3929,6 +4007,13 @@ uint8_t* ConnectionsLog_AdvertisingPhase::_InternalSerialize( 8, this->_internal_device_type(), target); } + // optional .location.nearby.proto.connections.SupportedService supported_service = 9; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 9, this->_internal_supported_service(), 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); @@ -3970,7 +4055,7 @@ size_t ConnectionsLog_AdvertisingPhase::ByteSizeLong() const { } cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x0000003fu) { // optional .location.nearby.analytics.proto.ConnectionsLog.AdvertisingMetadata advertising_metadata = 5; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -4000,6 +4085,12 @@ size_t ConnectionsLog_AdvertisingPhase::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_device_type()); } + // optional .location.nearby.proto.connections.SupportedService supported_service = 9; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_supported_service()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -4025,7 +4116,7 @@ void ConnectionsLog_AdvertisingPhase::MergeFrom(const ConnectionsLog_Advertising received_connection_request_.MergeFrom(from.received_connection_request_); adv_dis_result_.MergeFrom(from.adv_dis_result_); cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_advertising_metadata()->::location::nearby::analytics::proto::ConnectionsLog_AdvertisingMetadata::MergeFrom(from._internal_advertising_metadata()); } @@ -4041,6 +4132,9 @@ void ConnectionsLog_AdvertisingPhase::MergeFrom(const ConnectionsLog_Advertising if (cached_has_bits & 0x00000010u) { device_type_ = from.device_type_; } + if (cached_has_bits & 0x00000020u) { + supported_service_ = from.supported_service_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -4065,8 +4159,8 @@ void ConnectionsLog_AdvertisingPhase::InternalSwap(ConnectionsLog_AdvertisingPha received_connection_request_.InternalSwap(&other->received_connection_request_); adv_dis_result_.InternalSwap(&other->adv_dis_result_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ConnectionsLog_AdvertisingPhase, device_type_) - + sizeof(ConnectionsLog_AdvertisingPhase::device_type_) + PROTOBUF_FIELD_OFFSET(ConnectionsLog_AdvertisingPhase, supported_service_) + + sizeof(ConnectionsLog_AdvertisingPhase::supported_service_) - PROTOBUF_FIELD_OFFSET(ConnectionsLog_AdvertisingPhase, advertising_metadata_)>( reinterpret_cast(&advertising_metadata_), reinterpret_cast(&other->advertising_metadata_)); @@ -4441,6 +4535,15 @@ class ConnectionsLog_ConnectionAttempt::_Internal { static void set_has_device_type(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } + static void set_has_supported_service(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_wifi_connection_latency_millis(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_device_attestation_latency_millis(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } }; const ::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttemptMetadata& @@ -4483,8 +4586,8 @@ ConnectionsLog_ConnectionAttempt::ConnectionsLog_ConnectionAttempt(const Connect operation_result_ = nullptr; } ::memcpy(&duration_millis_, &from.duration_millis_, - static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&duration_millis_)) + sizeof(device_type_)); + static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&duration_millis_)) + sizeof(supported_service_)); // @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt) } @@ -4495,8 +4598,8 @@ connection_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyS #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&connection_attempt_metadata_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&connection_attempt_metadata_)) + sizeof(device_type_)); + 0, static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&connection_attempt_metadata_)) + sizeof(supported_service_)); } ConnectionsLog_ConnectionAttempt::~ConnectionsLog_ConnectionAttempt() { @@ -4548,10 +4651,10 @@ void ConnectionsLog_ConnectionAttempt::Clear() { reinterpret_cast(&attempt_result_) - reinterpret_cast(&duration_millis_)) + sizeof(attempt_result_)); } - if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00003f00u) { ::memset(&client_flow_id_, 0, static_cast( - reinterpret_cast(&device_type_) - - reinterpret_cast(&client_flow_id_)) + sizeof(device_type_)); + reinterpret_cast(&supported_service_) - + reinterpret_cast(&client_flow_id_)) + sizeof(supported_service_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -4685,6 +4788,37 @@ const char* ConnectionsLog_ConnectionAttempt::_InternalParse(const char* ptr, :: } else goto handle_unusual; continue; + // optional .location.nearby.proto.connections.SupportedService supported_service = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::connections::SupportedService_IsValid(val))) { + _internal_set_supported_service(static_cast<::location::nearby::proto::connections::SupportedService>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(12, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional int64 wifi_connection_latency_millis = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + _Internal::set_has_wifi_connection_latency_millis(&has_bits); + wifi_connection_latency_millis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 device_attestation_latency_millis = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + _Internal::set_has_device_attestation_latency_millis(&has_bits); + device_attestation_latency_millis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -4792,6 +4926,25 @@ uint8_t* ConnectionsLog_ConnectionAttempt::_InternalSerialize( 11, this->_internal_device_type(), target); } + // optional .location.nearby.proto.connections.SupportedService supported_service = 12; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 12, this->_internal_supported_service(), target); + } + + // optional int64 wifi_connection_latency_millis = 13; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(13, this->_internal_wifi_connection_latency_millis(), target); + } + + // optional int64 device_attestation_latency_millis = 14; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(14, this->_internal_device_attestation_latency_millis(), 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); @@ -4861,7 +5014,7 @@ size_t ConnectionsLog_ConnectionAttempt::ByteSizeLong() const { } } - if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00003f00u) { // optional int64 client_flow_id = 6; if (cached_has_bits & 0x00000100u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_client_flow_id()); @@ -4879,6 +5032,22 @@ size_t ConnectionsLog_ConnectionAttempt::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_device_type()); } + // optional int64 wifi_connection_latency_millis = 13; + if (cached_has_bits & 0x00000800u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_wifi_connection_latency_millis()); + } + + // optional int64 device_attestation_latency_millis = 14; + if (cached_has_bits & 0x00001000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_device_attestation_latency_millis()); + } + + // optional .location.nearby.proto.connections.SupportedService supported_service = 12; + if (cached_has_bits & 0x00002000u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_supported_service()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -4928,7 +5097,7 @@ void ConnectionsLog_ConnectionAttempt::MergeFrom(const ConnectionsLog_Connection } _has_bits_[0] |= cached_has_bits; } - if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00003f00u) { if (cached_has_bits & 0x00000100u) { client_flow_id_ = from.client_flow_id_; } @@ -4938,6 +5107,15 @@ void ConnectionsLog_ConnectionAttempt::MergeFrom(const ConnectionsLog_Connection if (cached_has_bits & 0x00000400u) { device_type_ = from.device_type_; } + if (cached_has_bits & 0x00000800u) { + wifi_connection_latency_millis_ = from.wifi_connection_latency_millis_; + } + if (cached_has_bits & 0x00001000u) { + device_attestation_latency_millis_ = from.device_attestation_latency_millis_; + } + if (cached_has_bits & 0x00002000u) { + supported_service_ = from.supported_service_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -4966,8 +5144,8 @@ void ConnectionsLog_ConnectionAttempt::InternalSwap(ConnectionsLog_ConnectionAtt &other->connection_token_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ConnectionsLog_ConnectionAttempt, device_type_) - + sizeof(ConnectionsLog_ConnectionAttempt::device_type_) + PROTOBUF_FIELD_OFFSET(ConnectionsLog_ConnectionAttempt, supported_service_) + + sizeof(ConnectionsLog_ConnectionAttempt::supported_service_) - PROTOBUF_FIELD_OFFSET(ConnectionsLog_ConnectionAttempt, connection_attempt_metadata_)>( reinterpret_cast(&connection_attempt_metadata_), reinterpret_cast(&other->connection_attempt_metadata_)); @@ -5610,6 +5788,9 @@ class ConnectionsLog_EstablishedConnection::_Internal { static void set_has_device_type(HasBits* has_bits) { (*has_bits)[0] |= 1024u; } + static void set_has_supported_service(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } }; const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& @@ -5665,8 +5846,8 @@ ConnectionsLog_EstablishedConnection::ConnectionsLog_EstablishedConnection(const disconnection_reason_detail_ = nullptr; } ::memcpy(&duration_millis_, &from.duration_millis_, - static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&duration_millis_)) + sizeof(device_type_)); + static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&duration_millis_)) + sizeof(supported_service_)); // @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection) } @@ -5677,8 +5858,8 @@ connection_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyS #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&operation_result_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&operation_result_)) + sizeof(device_type_)); + 0, static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&operation_result_)) + sizeof(supported_service_)); } ConnectionsLog_EstablishedConnection::~ConnectionsLog_EstablishedConnection() { @@ -5737,10 +5918,10 @@ void ConnectionsLog_EstablishedConnection::Clear() { reinterpret_cast(&client_flow_id_) - reinterpret_cast(&duration_millis_)) + sizeof(client_flow_id_)); } - if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000f00u) { ::memset(&type_, 0, static_cast( - reinterpret_cast(&device_type_) - - reinterpret_cast(&type_)) + sizeof(device_type_)); + reinterpret_cast(&supported_service_) - + reinterpret_cast(&type_)) + sizeof(supported_service_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -5895,6 +6076,19 @@ const char* ConnectionsLog_EstablishedConnection::_InternalParse(const char* ptr } else goto handle_unusual; continue; + // optional .location.nearby.proto.connections.SupportedService supported_service = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::connections::SupportedService_IsValid(val))) { + _internal_set_supported_service(static_cast<::location::nearby::proto::connections::SupportedService>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(14, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -6019,6 +6213,13 @@ uint8_t* ConnectionsLog_EstablishedConnection::_InternalSerialize( 13, this->_internal_device_type(), target); } + // optional .location.nearby.proto.connections.SupportedService supported_service = 14; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 14, this->_internal_supported_service(), 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); @@ -6102,7 +6303,7 @@ size_t ConnectionsLog_EstablishedConnection::ByteSizeLong() const { } } - if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000f00u) { // optional .location.nearby.proto.connections.ConnectionAttemptType type = 8; if (cached_has_bits & 0x00000100u) { total_size += 1 + @@ -6121,6 +6322,12 @@ size_t ConnectionsLog_EstablishedConnection::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_device_type()); } + // optional .location.nearby.proto.connections.SupportedService supported_service = 14; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_supported_service()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -6172,7 +6379,7 @@ void ConnectionsLog_EstablishedConnection::MergeFrom(const ConnectionsLog_Establ } _has_bits_[0] |= cached_has_bits; } - if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000f00u) { if (cached_has_bits & 0x00000100u) { type_ = from.type_; } @@ -6182,6 +6389,9 @@ void ConnectionsLog_EstablishedConnection::MergeFrom(const ConnectionsLog_Establ if (cached_has_bits & 0x00000400u) { device_type_ = from.device_type_; } + if (cached_has_bits & 0x00000800u) { + supported_service_ = from.supported_service_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -6212,8 +6422,8 @@ void ConnectionsLog_EstablishedConnection::InternalSwap(ConnectionsLog_Establish &other->connection_token_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ConnectionsLog_EstablishedConnection, device_type_) - + sizeof(ConnectionsLog_EstablishedConnection::device_type_) + PROTOBUF_FIELD_OFFSET(ConnectionsLog_EstablishedConnection, supported_service_) + + sizeof(ConnectionsLog_EstablishedConnection::supported_service_) - PROTOBUF_FIELD_OFFSET(ConnectionsLog_EstablishedConnection, operation_result_)>( reinterpret_cast(&operation_result_), reinterpret_cast(&other->operation_result_)); @@ -6224,38 +6434,360 @@ std::string ConnectionsLog_EstablishedConnection::GetTypeName() const { } +// =================================================================== + +class ConnectionsLog_DctPayloadTransferStats::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_is_multipart(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_num_parts_success(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_num_parts_failure(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_is_resumption(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +ConnectionsLog_DctPayloadTransferStats::ConnectionsLog_DctPayloadTransferStats(::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.analytics.proto.ConnectionsLog.DctPayloadTransferStats) +} +ConnectionsLog_DctPayloadTransferStats::ConnectionsLog_DctPayloadTransferStats(const ConnectionsLog_DctPayloadTransferStats& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&type_, &from.type_, + static_cast(reinterpret_cast(&num_parts_failure_) - + reinterpret_cast(&type_)) + sizeof(num_parts_failure_)); + // @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats) +} + +inline void ConnectionsLog_DctPayloadTransferStats::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&num_parts_failure_) - + reinterpret_cast(&type_)) + sizeof(num_parts_failure_)); +} + +ConnectionsLog_DctPayloadTransferStats::~ConnectionsLog_DctPayloadTransferStats() { + // @@protoc_insertion_point(destructor:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void ConnectionsLog_DctPayloadTransferStats::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void ConnectionsLog_DctPayloadTransferStats::ArenaDtor(void* object) { + ConnectionsLog_DctPayloadTransferStats* _this = reinterpret_cast< ConnectionsLog_DctPayloadTransferStats* >(object); + (void)_this; +} +void ConnectionsLog_DctPayloadTransferStats::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ConnectionsLog_DctPayloadTransferStats::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ConnectionsLog_DctPayloadTransferStats::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats) + 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) { + ::memset(&type_, 0, static_cast( + reinterpret_cast(&num_parts_failure_) - + reinterpret_cast(&type_)) + sizeof(num_parts_failure_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* ConnectionsLog_DctPayloadTransferStats::_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.proto.connections.DctPayloadType 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::proto::connections::DctPayloadType_IsValid(val))) { + _internal_set_type(static_cast<::location::nearby::proto::connections::DctPayloadType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool is_multipart = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_is_multipart(&has_bits); + is_multipart_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 num_parts_success = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_num_parts_success(&has_bits); + num_parts_success_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 num_parts_failure = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_num_parts_failure(&has_bits); + num_parts_failure_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool is_resumption = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_is_resumption(&has_bits); + is_resumption_ = ::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* ConnectionsLog_DctPayloadTransferStats::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.proto.connections.DctPayloadType type = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_type(), target); + } + + // optional bool is_multipart = 2; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_is_multipart(), target); + } + + // optional int32 num_parts_success = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_num_parts_success(), target); + } + + // optional int32 num_parts_failure = 4; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_num_parts_failure(), target); + } + + // optional bool is_resumption = 5; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_is_resumption(), 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.analytics.proto.ConnectionsLog.DctPayloadTransferStats) + return target; +} + +size_t ConnectionsLog_DctPayloadTransferStats::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats) + 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 .location.nearby.proto.connections.DctPayloadType type = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + // optional int32 num_parts_success = 3; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_parts_success()); + } + + // optional bool is_multipart = 2; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + 1; + } + + // optional bool is_resumption = 5; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + // optional int32 num_parts_failure = 4; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_parts_failure()); + } + + } + 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 ConnectionsLog_DctPayloadTransferStats::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void ConnectionsLog_DctPayloadTransferStats::MergeFrom(const ConnectionsLog_DctPayloadTransferStats& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats) + 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) { + type_ = from.type_; + } + if (cached_has_bits & 0x00000002u) { + num_parts_success_ = from.num_parts_success_; + } + if (cached_has_bits & 0x00000004u) { + is_multipart_ = from.is_multipart_; + } + if (cached_has_bits & 0x00000008u) { + is_resumption_ = from.is_resumption_; + } + if (cached_has_bits & 0x00000010u) { + num_parts_failure_ = from.num_parts_failure_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ConnectionsLog_DctPayloadTransferStats::CopyFrom(const ConnectionsLog_DctPayloadTransferStats& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ConnectionsLog_DctPayloadTransferStats::IsInitialized() const { + return true; +} + +void ConnectionsLog_DctPayloadTransferStats::InternalSwap(ConnectionsLog_DctPayloadTransferStats* 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(ConnectionsLog_DctPayloadTransferStats, num_parts_failure_) + + sizeof(ConnectionsLog_DctPayloadTransferStats::num_parts_failure_) + - PROTOBUF_FIELD_OFFSET(ConnectionsLog_DctPayloadTransferStats, type_)>( + reinterpret_cast(&type_), + reinterpret_cast(&other->type_)); +} + +std::string ConnectionsLog_DctPayloadTransferStats::GetTypeName() const { + return "location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats"; +} + + // =================================================================== class ConnectionsLog_Payload::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_duration_millis(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_type(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_total_size_bytes(HasBits* has_bits) { (*has_bits)[0] |= 4u; } - static void set_has_num_bytes_transferred(HasBits* has_bits) { - (*has_bits)[0] |= 32u; - } - static void set_has_num_chunks(HasBits* has_bits) { + static void set_has_type(HasBits* has_bits) { (*has_bits)[0] |= 16u; } - static void set_has_status(HasBits* has_bits) { + static void set_has_total_size_bytes(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_num_bytes_transferred(HasBits* has_bits) { (*has_bits)[0] |= 64u; } - static void set_has_num_successful_auto_resume(HasBits* has_bits) { + static void set_has_num_chunks(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_status(HasBits* has_bits) { (*has_bits)[0] |= 128u; } + static void set_has_num_successful_auto_resume(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } static const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& operation_result(const ConnectionsLog_Payload* msg); static void set_has_operation_result(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_num_failed_auto_resume(HasBits* has_bits) { - (*has_bits)[0] |= 256u; + (*has_bits)[0] |= 512u; + } + static const ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats& dct_payload_transfer_stats(const ConnectionsLog_Payload* msg); + static void set_has_dct_payload_transfer_stats(HasBits* has_bits) { + (*has_bits)[0] |= 2u; } }; @@ -6263,6 +6795,10 @@ const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& ConnectionsLog_Payload::_Internal::operation_result(const ConnectionsLog_Payload* msg) { return *msg->operation_result_; } +const ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats& +ConnectionsLog_Payload::_Internal::dct_payload_transfer_stats(const ConnectionsLog_Payload* msg) { + return *msg->dct_payload_transfer_stats_; +} ConnectionsLog_Payload::ConnectionsLog_Payload(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { @@ -6281,6 +6817,11 @@ ConnectionsLog_Payload::ConnectionsLog_Payload(const ConnectionsLog_Payload& fro } else { operation_result_ = nullptr; } + if (from._internal_has_dct_payload_transfer_stats()) { + dct_payload_transfer_stats_ = new ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats(*from.dct_payload_transfer_stats_); + } else { + dct_payload_transfer_stats_ = nullptr; + } ::memcpy(&duration_millis_, &from.duration_millis_, static_cast(reinterpret_cast(&num_failed_auto_resume_) - reinterpret_cast(&duration_millis_)) + sizeof(num_failed_auto_resume_)); @@ -6304,6 +6845,7 @@ ConnectionsLog_Payload::~ConnectionsLog_Payload() { inline void ConnectionsLog_Payload::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete operation_result_; + if (this != internal_default_instance()) delete dct_payload_transfer_stats_; } void ConnectionsLog_Payload::ArenaDtor(void* object) { @@ -6323,16 +6865,26 @@ void ConnectionsLog_Payload::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(operation_result_ != nullptr); - operation_result_->Clear(); + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(operation_result_ != nullptr); + operation_result_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(dct_payload_transfer_stats_ != nullptr); + dct_payload_transfer_stats_->Clear(); + } } - if (cached_has_bits & 0x000000feu) { + if (cached_has_bits & 0x000000fcu) { ::memset(&duration_millis_, 0, static_cast( - reinterpret_cast(&num_successful_auto_resume_) - - reinterpret_cast(&duration_millis_)) + sizeof(num_successful_auto_resume_)); + reinterpret_cast(&status_) - + reinterpret_cast(&duration_millis_)) + sizeof(status_)); + } + if (cached_has_bits & 0x00000300u) { + ::memset(&num_successful_auto_resume_, 0, static_cast( + reinterpret_cast(&num_failed_auto_resume_) - + reinterpret_cast(&num_successful_auto_resume_)) + sizeof(num_failed_auto_resume_)); } - num_failed_auto_resume_ = 0; _has_bits_.Clear(); _internal_metadata_.Clear(); } @@ -6432,6 +6984,14 @@ const char* ConnectionsLog_Payload::_InternalParse(const char* ptr, ::PROTOBUF_N } else goto handle_unusual; continue; + // optional .location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats dct_payload_transfer_stats = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_dct_payload_transfer_stats(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -6464,45 +7024,45 @@ uint8_t* ConnectionsLog_Payload::_InternalSerialize( cached_has_bits = _has_bits_[0]; // optional int64 duration_millis = 1; - if (cached_has_bits & 0x00000002u) { + if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_duration_millis(), target); } // optional .location.nearby.proto.connections.PayloadType type = 2; - if (cached_has_bits & 0x00000008u) { + 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_bytes = 3; - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_total_size_bytes(), target); } // optional int64 num_bytes_transferred = 4; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_num_bytes_transferred(), target); } // optional int32 num_chunks = 5; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_num_chunks(), target); } // optional .location.nearby.proto.connections.PayloadStatus status = 6; - if (cached_has_bits & 0x00000040u) { + if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 6, this->_internal_status(), target); } // optional int32 num_successful_auto_resume = 7; - if (cached_has_bits & 0x00000080u) { + if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_num_successful_auto_resume(), target); } @@ -6516,11 +7076,19 @@ uint8_t* ConnectionsLog_Payload::_InternalSerialize( } // optional int32 num_failed_auto_resume = 9; - if (cached_has_bits & 0x00000100u) { + if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(9, this->_internal_num_failed_auto_resume(), target); } + // optional .location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats dct_payload_transfer_stats = 10; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::dct_payload_transfer_stats(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); @@ -6546,49 +7114,58 @@ size_t ConnectionsLog_Payload::ByteSizeLong() const { *operation_result_); } - // optional int64 duration_millis = 1; + // optional .location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats dct_payload_transfer_stats = 10; if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *dct_payload_transfer_stats_); + } + + // optional int64 duration_millis = 1; + if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis()); } // optional int64 total_size_bytes = 3; - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_total_size_bytes()); } // optional .location.nearby.proto.connections.PayloadType type = 2; - if (cached_has_bits & 0x00000008u) { + if (cached_has_bits & 0x00000010u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); } // optional int32 num_chunks = 5; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_chunks()); } // optional int64 num_bytes_transferred = 4; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000040u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_num_bytes_transferred()); } // optional .location.nearby.proto.connections.PayloadStatus status = 6; - if (cached_has_bits & 0x00000040u) { + if (cached_has_bits & 0x00000080u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status()); } + } + if (cached_has_bits & 0x00000300u) { // optional int32 num_successful_auto_resume = 7; - if (cached_has_bits & 0x00000080u) { + if (cached_has_bits & 0x00000100u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_successful_auto_resume()); } - } - // optional int32 num_failed_auto_resume = 9; - if (cached_has_bits & 0x00000100u) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_failed_auto_resume()); - } + // optional int32 num_failed_auto_resume = 9; + if (cached_has_bits & 0x00000200u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_failed_auto_resume()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); } @@ -6615,30 +7192,36 @@ void ConnectionsLog_Payload::MergeFrom(const ConnectionsLog_Payload& from) { _internal_mutable_operation_result()->::location::nearby::analytics::proto::ConnectionsLog_OperationResult::MergeFrom(from._internal_operation_result()); } if (cached_has_bits & 0x00000002u) { - duration_millis_ = from.duration_millis_; + _internal_mutable_dct_payload_transfer_stats()->::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats::MergeFrom(from._internal_dct_payload_transfer_stats()); } if (cached_has_bits & 0x00000004u) { - total_size_bytes_ = from.total_size_bytes_; + duration_millis_ = from.duration_millis_; } if (cached_has_bits & 0x00000008u) { - type_ = from.type_; + total_size_bytes_ = from.total_size_bytes_; } if (cached_has_bits & 0x00000010u) { - num_chunks_ = from.num_chunks_; + type_ = from.type_; } if (cached_has_bits & 0x00000020u) { - num_bytes_transferred_ = from.num_bytes_transferred_; + num_chunks_ = from.num_chunks_; } if (cached_has_bits & 0x00000040u) { - status_ = from.status_; + num_bytes_transferred_ = from.num_bytes_transferred_; } if (cached_has_bits & 0x00000080u) { - num_successful_auto_resume_ = from.num_successful_auto_resume_; + status_ = from.status_; } _has_bits_[0] |= cached_has_bits; } - if (cached_has_bits & 0x00000100u) { - _internal_set_num_failed_auto_resume(from._internal_num_failed_auto_resume()); + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + num_successful_auto_resume_ = from.num_successful_auto_resume_; + } + if (cached_has_bits & 0x00000200u) { + num_failed_auto_resume_ = from.num_failed_auto_resume_; + } + _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); } @@ -6707,6 +7290,9 @@ class ConnectionsLog_BandwidthUpgradeAttempt::_Internal { static void set_has_device_type(HasBits* has_bits) { (*has_bits)[0] |= 512u; } + static void set_has_supported_service(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } }; const ::location::nearby::analytics::proto::ConnectionsLog_OperationResult& @@ -6740,8 +7326,8 @@ ConnectionsLog_BandwidthUpgradeAttempt::ConnectionsLog_BandwidthUpgradeAttempt(c operation_result_ = nullptr; } ::memcpy(&duration_millis_, &from.duration_millis_, - static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&duration_millis_)) + sizeof(device_type_)); + static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&duration_millis_)) + sizeof(supported_service_)); // @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt) } @@ -6752,8 +7338,8 @@ connection_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyS #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&operation_result_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&device_type_) - - reinterpret_cast(&operation_result_)) + sizeof(device_type_)); + 0, static_cast(reinterpret_cast(&supported_service_) - + reinterpret_cast(&operation_result_)) + sizeof(supported_service_)); } ConnectionsLog_BandwidthUpgradeAttempt::~ConnectionsLog_BandwidthUpgradeAttempt() { @@ -6800,10 +7386,10 @@ void ConnectionsLog_BandwidthUpgradeAttempt::Clear() { reinterpret_cast(&client_flow_id_) - reinterpret_cast(&duration_millis_)) + sizeof(client_flow_id_)); } - if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000700u) { ::memset(&error_stage_, 0, static_cast( - reinterpret_cast(&device_type_) - - reinterpret_cast(&error_stage_)) + sizeof(device_type_)); + reinterpret_cast(&supported_service_) - + reinterpret_cast(&error_stage_)) + sizeof(supported_service_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -6929,6 +7515,19 @@ const char* ConnectionsLog_BandwidthUpgradeAttempt::_InternalParse(const char* p } else goto handle_unusual; continue; + // optional .location.nearby.proto.connections.SupportedService supported_service = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::connections::SupportedService_IsValid(val))) { + _internal_set_supported_service(static_cast<::location::nearby::proto::connections::SupportedService>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -7028,6 +7627,13 @@ uint8_t* ConnectionsLog_BandwidthUpgradeAttempt::_InternalSerialize( 10, this->_internal_device_type(), target); } + // optional .location.nearby.proto.connections.SupportedService supported_service = 11; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 11, this->_internal_supported_service(), 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); @@ -7095,7 +7701,7 @@ size_t ConnectionsLog_BandwidthUpgradeAttempt::ByteSizeLong() const { } } - if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000700u) { // optional .location.nearby.proto.connections.BandwidthUpgradeErrorStage error_stage = 6; if (cached_has_bits & 0x00000100u) { total_size += 1 + @@ -7108,6 +7714,12 @@ size_t ConnectionsLog_BandwidthUpgradeAttempt::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_device_type()); } + // optional .location.nearby.proto.connections.SupportedService supported_service = 11; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_supported_service()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -7157,13 +7769,16 @@ void ConnectionsLog_BandwidthUpgradeAttempt::MergeFrom(const ConnectionsLog_Band } _has_bits_[0] |= cached_has_bits; } - if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000700u) { if (cached_has_bits & 0x00000100u) { error_stage_ = from.error_stage_; } if (cached_has_bits & 0x00000200u) { device_type_ = from.device_type_; } + if (cached_has_bits & 0x00000400u) { + supported_service_ = from.supported_service_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -7192,8 +7807,8 @@ void ConnectionsLog_BandwidthUpgradeAttempt::InternalSwap(ConnectionsLog_Bandwid &other->connection_token_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ConnectionsLog_BandwidthUpgradeAttempt, device_type_) - + sizeof(ConnectionsLog_BandwidthUpgradeAttempt::device_type_) + PROTOBUF_FIELD_OFFSET(ConnectionsLog_BandwidthUpgradeAttempt, supported_service_) + + sizeof(ConnectionsLog_BandwidthUpgradeAttempt::supported_service_) - PROTOBUF_FIELD_OFFSET(ConnectionsLog_BandwidthUpgradeAttempt, operation_result_)>( reinterpret_cast(&operation_result_), reinterpret_cast(&other->operation_result_)); @@ -10022,6 +10637,9 @@ template<> PROTOBUF_NOINLINE ::location::nearby::analytics::proto::ConnectionsLo template<> PROTOBUF_NOINLINE ::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection* Arena::CreateMaybeMessage< ::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection >(Arena* arena) { return Arena::CreateMessageInternal< ::location::nearby::analytics::proto::ConnectionsLog_EstablishedConnection >(arena); } +template<> PROTOBUF_NOINLINE ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* Arena::CreateMaybeMessage< ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats >(arena); +} template<> PROTOBUF_NOINLINE ::location::nearby::analytics::proto::ConnectionsLog_Payload* Arena::CreateMaybeMessage< ::location::nearby::analytics::proto::ConnectionsLog_Payload >(Arena* arena) { return Arena::CreateMessageInternal< ::location::nearby::analytics::proto::ConnectionsLog_Payload >(arena); } diff --git a/compiled_proto/internal/proto/analytics/connections_log.pb.h b/compiled_proto/internal/proto/analytics/connections_log.pb.h index d9a4f7a7..f6cf76e3 100644 --- a/compiled_proto/internal/proto/analytics/connections_log.pb.h +++ b/compiled_proto/internal/proto/analytics/connections_log.pb.h @@ -13,7 +13,7 @@ #error incompatible with your Protocol Buffer headers. Please update #error your headers. #endif -#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019005 < 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. @@ -47,7 +47,7 @@ struct TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto { 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[21] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[22] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -81,6 +81,9 @@ extern ConnectionsLog_ConnectionAttemptMetadataDefaultTypeInternal _ConnectionsL class ConnectionsLog_ConnectionRequest; struct ConnectionsLog_ConnectionRequestDefaultTypeInternal; extern ConnectionsLog_ConnectionRequestDefaultTypeInternal _ConnectionsLog_ConnectionRequest_default_instance_; +class ConnectionsLog_DctPayloadTransferStats; +struct ConnectionsLog_DctPayloadTransferStatsDefaultTypeInternal; +extern ConnectionsLog_DctPayloadTransferStatsDefaultTypeInternal _ConnectionsLog_DctPayloadTransferStats_default_instance_; class ConnectionsLog_DeviceInfo; struct ConnectionsLog_DeviceInfoDefaultTypeInternal; extern ConnectionsLog_DeviceInfoDefaultTypeInternal _ConnectionsLog_DeviceInfo_default_instance_; @@ -133,6 +136,7 @@ template<> ::location::nearby::analytics::proto::ConnectionsLog_ClientSession* A template<> ::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttempt* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttempt>(Arena*); template<> ::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttemptMetadata* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_ConnectionAttemptMetadata>(Arena*); template<> ::location::nearby::analytics::proto::ConnectionsLog_ConnectionRequest* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_ConnectionRequest>(Arena*); +template<> ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats>(Arena*); template<> ::location::nearby::analytics::proto::ConnectionsLog_DeviceInfo* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_DeviceInfo>(Arena*); template<> ::location::nearby::analytics::proto::ConnectionsLog_DisconnectionReasonDetail* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_DisconnectionReasonDetail>(Arena*); template<> ::location::nearby::analytics::proto::ConnectionsLog_DiscoveredEndpoint* Arena::CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_DiscoveredEndpoint>(Arena*); @@ -1206,6 +1210,7 @@ class ConnectionsLog_DiscoveryPhase final : kClientFlowIdFieldNumber = 6, kStopReasonFieldNumber = 9, kDeviceTypeFieldNumber = 10, + kSupportedServiceFieldNumber = 11, }; // repeated .location.nearby.proto.connections.Medium medium = 2; int medium_size() const; @@ -1366,6 +1371,19 @@ class ConnectionsLog_DiscoveryPhase final : void _internal_set_device_type(::location::nearby::proto::connections::DeviceType value); public: + // optional .location.nearby.proto.connections.SupportedService supported_service = 11; + bool has_supported_service() const; + private: + bool _internal_has_supported_service() const; + public: + void clear_supported_service(); + ::location::nearby::proto::connections::SupportedService supported_service() const; + void set_supported_service(::location::nearby::proto::connections::SupportedService value); + private: + ::location::nearby::proto::connections::SupportedService _internal_supported_service() const; + void _internal_set_supported_service(::location::nearby::proto::connections::SupportedService value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.DiscoveryPhase) private: class _Internal; @@ -1385,6 +1403,7 @@ class ConnectionsLog_DiscoveryPhase final : int64_t client_flow_id_; int stop_reason_; int device_type_; + int supported_service_; friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -2136,6 +2155,7 @@ class ConnectionsLog_AdvertisingPhase final : kClientFlowIdFieldNumber = 4, kStopReasonFieldNumber = 7, kDeviceTypeFieldNumber = 8, + kSupportedServiceFieldNumber = 9, }; // repeated .location.nearby.proto.connections.Medium medium = 2; int medium_size() const; @@ -2260,6 +2280,19 @@ class ConnectionsLog_AdvertisingPhase final : void _internal_set_device_type(::location::nearby::proto::connections::DeviceType value); public: + // optional .location.nearby.proto.connections.SupportedService supported_service = 9; + bool has_supported_service() const; + private: + bool _internal_has_supported_service() const; + public: + void clear_supported_service(); + ::location::nearby::proto::connections::SupportedService supported_service() const; + void set_supported_service(::location::nearby::proto::connections::SupportedService value); + private: + ::location::nearby::proto::connections::SupportedService _internal_supported_service() const; + void _internal_set_supported_service(::location::nearby::proto::connections::SupportedService value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.AdvertisingPhase) private: class _Internal; @@ -2277,6 +2310,7 @@ class ConnectionsLog_AdvertisingPhase final : int64_t client_flow_id_; int stop_reason_; int device_type_; + int supported_service_; friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -2607,6 +2641,9 @@ class ConnectionsLog_ConnectionAttempt final : kClientFlowIdFieldNumber = 6, kConnectionModeFieldNumber = 10, kDeviceTypeFieldNumber = 11, + kWifiConnectionLatencyMillisFieldNumber = 13, + kDeviceAttestationLatencyMillisFieldNumber = 14, + kSupportedServiceFieldNumber = 12, }; // optional string connection_token = 7; bool has_connection_token() const; @@ -2766,6 +2803,45 @@ class ConnectionsLog_ConnectionAttempt final : void _internal_set_device_type(::location::nearby::proto::connections::DeviceType value); public: + // optional int64 wifi_connection_latency_millis = 13; + bool has_wifi_connection_latency_millis() const; + private: + bool _internal_has_wifi_connection_latency_millis() const; + public: + void clear_wifi_connection_latency_millis(); + int64_t wifi_connection_latency_millis() const; + void set_wifi_connection_latency_millis(int64_t value); + private: + int64_t _internal_wifi_connection_latency_millis() const; + void _internal_set_wifi_connection_latency_millis(int64_t value); + public: + + // optional int64 device_attestation_latency_millis = 14; + bool has_device_attestation_latency_millis() const; + private: + bool _internal_has_device_attestation_latency_millis() const; + public: + void clear_device_attestation_latency_millis(); + int64_t device_attestation_latency_millis() const; + void set_device_attestation_latency_millis(int64_t value); + private: + int64_t _internal_device_attestation_latency_millis() const; + void _internal_set_device_attestation_latency_millis(int64_t value); + public: + + // optional .location.nearby.proto.connections.SupportedService supported_service = 12; + bool has_supported_service() const; + private: + bool _internal_has_supported_service() const; + public: + void clear_supported_service(); + ::location::nearby::proto::connections::SupportedService supported_service() const; + void set_supported_service(::location::nearby::proto::connections::SupportedService value); + private: + ::location::nearby::proto::connections::SupportedService _internal_supported_service() const; + void _internal_set_supported_service(::location::nearby::proto::connections::SupportedService value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt) private: class _Internal; @@ -2786,6 +2862,9 @@ class ConnectionsLog_ConnectionAttempt final : int64_t client_flow_id_; int connection_mode_; int device_type_; + int64_t wifi_connection_latency_millis_; + int64_t device_attestation_latency_millis_; + int supported_service_; friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -3393,6 +3472,7 @@ class ConnectionsLog_EstablishedConnection final : kTypeFieldNumber = 8, kSafeDisconnectionResultFieldNumber = 9, kDeviceTypeFieldNumber = 13, + kSupportedServiceFieldNumber = 14, }; // repeated .location.nearby.analytics.proto.ConnectionsLog.Payload sent_payload = 3; int sent_payload_size() const; @@ -3593,6 +3673,19 @@ class ConnectionsLog_EstablishedConnection final : void _internal_set_device_type(::location::nearby::proto::connections::DeviceType value); public: + // optional .location.nearby.proto.connections.SupportedService supported_service = 14; + bool has_supported_service() const; + private: + bool _internal_has_supported_service() const; + public: + void clear_supported_service(); + ::location::nearby::proto::connections::SupportedService supported_service() const; + void set_supported_service(::location::nearby::proto::connections::SupportedService value); + private: + ::location::nearby::proto::connections::SupportedService _internal_supported_service() const; + void _internal_set_supported_service(::location::nearby::proto::connections::SupportedService value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection) private: class _Internal; @@ -3615,6 +3708,209 @@ class ConnectionsLog_EstablishedConnection final : int type_; int safe_disconnection_result_; int device_type_; + int supported_service_; + friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class ConnectionsLog_DctPayloadTransferStats final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats) */ { + public: + inline ConnectionsLog_DctPayloadTransferStats() : ConnectionsLog_DctPayloadTransferStats(nullptr) {} + ~ConnectionsLog_DctPayloadTransferStats() override; + explicit constexpr ConnectionsLog_DctPayloadTransferStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ConnectionsLog_DctPayloadTransferStats(const ConnectionsLog_DctPayloadTransferStats& from); + ConnectionsLog_DctPayloadTransferStats(ConnectionsLog_DctPayloadTransferStats&& from) noexcept + : ConnectionsLog_DctPayloadTransferStats() { + *this = ::std::move(from); + } + + inline ConnectionsLog_DctPayloadTransferStats& operator=(const ConnectionsLog_DctPayloadTransferStats& from) { + CopyFrom(from); + return *this; + } + inline ConnectionsLog_DctPayloadTransferStats& operator=(ConnectionsLog_DctPayloadTransferStats&& 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 ConnectionsLog_DctPayloadTransferStats& default_instance() { + return *internal_default_instance(); + } + static inline const ConnectionsLog_DctPayloadTransferStats* internal_default_instance() { + return reinterpret_cast( + &_ConnectionsLog_DctPayloadTransferStats_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(ConnectionsLog_DctPayloadTransferStats& a, ConnectionsLog_DctPayloadTransferStats& b) { + a.Swap(&b); + } + inline void Swap(ConnectionsLog_DctPayloadTransferStats* 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(ConnectionsLog_DctPayloadTransferStats* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ConnectionsLog_DctPayloadTransferStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const ConnectionsLog_DctPayloadTransferStats& from); + void MergeFrom(const ConnectionsLog_DctPayloadTransferStats& 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(ConnectionsLog_DctPayloadTransferStats* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats"; + } + protected: + explicit ConnectionsLog_DctPayloadTransferStats(::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 { + kTypeFieldNumber = 1, + kNumPartsSuccessFieldNumber = 3, + kIsMultipartFieldNumber = 2, + kIsResumptionFieldNumber = 5, + kNumPartsFailureFieldNumber = 4, + }; + // optional .location.nearby.proto.connections.DctPayloadType type = 1; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::location::nearby::proto::connections::DctPayloadType type() const; + void set_type(::location::nearby::proto::connections::DctPayloadType value); + private: + ::location::nearby::proto::connections::DctPayloadType _internal_type() const; + void _internal_set_type(::location::nearby::proto::connections::DctPayloadType value); + public: + + // optional int32 num_parts_success = 3; + bool has_num_parts_success() const; + private: + bool _internal_has_num_parts_success() const; + public: + void clear_num_parts_success(); + int32_t num_parts_success() const; + void set_num_parts_success(int32_t value); + private: + int32_t _internal_num_parts_success() const; + void _internal_set_num_parts_success(int32_t value); + public: + + // optional bool is_multipart = 2; + bool has_is_multipart() const; + private: + bool _internal_has_is_multipart() const; + public: + void clear_is_multipart(); + bool is_multipart() const; + void set_is_multipart(bool value); + private: + bool _internal_is_multipart() const; + void _internal_set_is_multipart(bool value); + public: + + // optional bool is_resumption = 5; + bool has_is_resumption() const; + private: + bool _internal_has_is_resumption() const; + public: + void clear_is_resumption(); + bool is_resumption() const; + void set_is_resumption(bool value); + private: + bool _internal_is_resumption() const; + void _internal_set_is_resumption(bool value); + public: + + // optional int32 num_parts_failure = 4; + bool has_num_parts_failure() const; + private: + bool _internal_has_num_parts_failure() const; + public: + void clear_num_parts_failure(); + int32_t num_parts_failure() const; + void set_num_parts_failure(int32_t value); + private: + int32_t _internal_num_parts_failure() const; + void _internal_set_num_parts_failure(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats) + 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_; + int type_; + int32_t num_parts_success_; + bool is_multipart_; + bool is_resumption_; + int32_t num_parts_failure_; friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -3665,7 +3961,7 @@ class ConnectionsLog_Payload final : &_ConnectionsLog_Payload_default_instance_); } static constexpr int kIndexInFileMessages = - 14; + 15; friend void swap(ConnectionsLog_Payload& a, ConnectionsLog_Payload& b) { a.Swap(&b); @@ -3733,6 +4029,7 @@ class ConnectionsLog_Payload final : enum : int { kOperationResultFieldNumber = 8, + kDctPayloadTransferStatsFieldNumber = 10, kDurationMillisFieldNumber = 1, kTotalSizeBytesFieldNumber = 3, kTypeFieldNumber = 2, @@ -3760,6 +4057,24 @@ class ConnectionsLog_Payload final : ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result); ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* unsafe_arena_release_operation_result(); + // optional .location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats dct_payload_transfer_stats = 10; + bool has_dct_payload_transfer_stats() const; + private: + bool _internal_has_dct_payload_transfer_stats() const; + public: + void clear_dct_payload_transfer_stats(); + const ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats& dct_payload_transfer_stats() const; + PROTOBUF_NODISCARD ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* release_dct_payload_transfer_stats(); + ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* mutable_dct_payload_transfer_stats(); + void set_allocated_dct_payload_transfer_stats(::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* dct_payload_transfer_stats); + private: + const ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats& _internal_dct_payload_transfer_stats() const; + ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* _internal_mutable_dct_payload_transfer_stats(); + public: + void unsafe_arena_set_allocated_dct_payload_transfer_stats( + ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* dct_payload_transfer_stats); + ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* unsafe_arena_release_dct_payload_transfer_stats(); + // optional int64 duration_millis = 1; bool has_duration_millis() const; private: @@ -3874,6 +4189,7 @@ class ConnectionsLog_Payload final : ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::location::nearby::analytics::proto::ConnectionsLog_OperationResult* operation_result_; + ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* dct_payload_transfer_stats_; int64_t duration_millis_; int64_t total_size_bytes_; int type_; @@ -3932,7 +4248,7 @@ class ConnectionsLog_BandwidthUpgradeAttempt final : &_ConnectionsLog_BandwidthUpgradeAttempt_default_instance_); } static constexpr int kIndexInFileMessages = - 15; + 16; friend void swap(ConnectionsLog_BandwidthUpgradeAttempt& a, ConnectionsLog_BandwidthUpgradeAttempt& b) { a.Swap(&b); @@ -4009,6 +4325,7 @@ class ConnectionsLog_BandwidthUpgradeAttempt final : kClientFlowIdFieldNumber = 7, kErrorStageFieldNumber = 6, kDeviceTypeFieldNumber = 10, + kSupportedServiceFieldNumber = 11, }; // optional string connection_token = 8; bool has_connection_token() const; @@ -4150,6 +4467,19 @@ class ConnectionsLog_BandwidthUpgradeAttempt final : void _internal_set_device_type(::location::nearby::proto::connections::DeviceType value); public: + // optional .location.nearby.proto.connections.SupportedService supported_service = 11; + bool has_supported_service() const; + private: + bool _internal_has_supported_service() const; + public: + void clear_supported_service(); + ::location::nearby::proto::connections::SupportedService supported_service() const; + void set_supported_service(::location::nearby::proto::connections::SupportedService value); + private: + ::location::nearby::proto::connections::SupportedService _internal_supported_service() const; + void _internal_set_supported_service(::location::nearby::proto::connections::SupportedService value); + public: + // @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt) private: class _Internal; @@ -4169,6 +4499,7 @@ class ConnectionsLog_BandwidthUpgradeAttempt final : int64_t client_flow_id_; int error_stage_; int device_type_; + int supported_service_; friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -4237,7 +4568,7 @@ class ConnectionsLog_ErrorCode final : &_ConnectionsLog_ErrorCode_default_instance_); } static constexpr int kIndexInFileMessages = - 16; + 17; friend void swap(ConnectionsLog_ErrorCode& a, ConnectionsLog_ErrorCode& b) { a.Swap(&b); @@ -4714,7 +5045,7 @@ class ConnectionsLog_AdvertisingMetadata final : &_ConnectionsLog_AdvertisingMetadata_default_instance_); } static constexpr int kIndexInFileMessages = - 17; + 18; friend void swap(ConnectionsLog_AdvertisingMetadata& a, ConnectionsLog_AdvertisingMetadata& b) { a.Swap(&b); @@ -4961,7 +5292,7 @@ class ConnectionsLog_DiscoveryMetadata final : &_ConnectionsLog_DiscoveryMetadata_default_instance_); } static constexpr int kIndexInFileMessages = - 18; + 19; friend void swap(ConnectionsLog_DiscoveryMetadata& a, ConnectionsLog_DiscoveryMetadata& b) { a.Swap(&b); @@ -5148,7 +5479,7 @@ class ConnectionsLog_ConnectionAttemptMetadata final : &_ConnectionsLog_ConnectionAttemptMetadata_default_instance_); } static constexpr int kIndexInFileMessages = - 19; + 20; friend void swap(ConnectionsLog_ConnectionAttemptMetadata& a, ConnectionsLog_ConnectionAttemptMetadata& b) { a.Swap(&b); @@ -5510,7 +5841,7 @@ class ConnectionsLog final : &_ConnectionsLog_default_instance_); } static constexpr int kIndexInFileMessages = - 20; + 21; friend void swap(ConnectionsLog& a, ConnectionsLog& b) { a.Swap(&b); @@ -5588,6 +5919,7 @@ class ConnectionsLog final : typedef ConnectionsLog_DeviceInfo DeviceInfo; typedef ConnectionsLog_DisconnectionReasonDetail DisconnectionReasonDetail; typedef ConnectionsLog_EstablishedConnection EstablishedConnection; + typedef ConnectionsLog_DctPayloadTransferStats DctPayloadTransferStats; typedef ConnectionsLog_Payload Payload; typedef ConnectionsLog_BandwidthUpgradeAttempt BandwidthUpgradeAttempt; typedef ConnectionsLog_ErrorCode ErrorCode; @@ -6894,6 +7226,35 @@ inline void ConnectionsLog_DiscoveryPhase::set_device_type(::location::nearby::p // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.DiscoveryPhase.device_type) } +// optional .location.nearby.proto.connections.SupportedService supported_service = 11; +inline bool ConnectionsLog_DiscoveryPhase::_internal_has_supported_service() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ConnectionsLog_DiscoveryPhase::has_supported_service() const { + return _internal_has_supported_service(); +} +inline void ConnectionsLog_DiscoveryPhase::clear_supported_service() { + supported_service_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_DiscoveryPhase::_internal_supported_service() const { + return static_cast< ::location::nearby::proto::connections::SupportedService >(supported_service_); +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_DiscoveryPhase::supported_service() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.DiscoveryPhase.supported_service) + return _internal_supported_service(); +} +inline void ConnectionsLog_DiscoveryPhase::_internal_set_supported_service(::location::nearby::proto::connections::SupportedService value) { + assert(::location::nearby::proto::connections::SupportedService_IsValid(value)); + _has_bits_[0] |= 0x00000020u; + supported_service_ = value; +} +inline void ConnectionsLog_DiscoveryPhase::set_supported_service(::location::nearby::proto::connections::SupportedService value) { + _internal_set_supported_service(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.DiscoveryPhase.supported_service) +} + // ------------------------------------------------------------------- // ConnectionsLog_DiscoveredEndpoint @@ -7700,6 +8061,35 @@ inline void ConnectionsLog_AdvertisingPhase::set_device_type(::location::nearby: // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.AdvertisingPhase.device_type) } +// optional .location.nearby.proto.connections.SupportedService supported_service = 9; +inline bool ConnectionsLog_AdvertisingPhase::_internal_has_supported_service() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ConnectionsLog_AdvertisingPhase::has_supported_service() const { + return _internal_has_supported_service(); +} +inline void ConnectionsLog_AdvertisingPhase::clear_supported_service() { + supported_service_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_AdvertisingPhase::_internal_supported_service() const { + return static_cast< ::location::nearby::proto::connections::SupportedService >(supported_service_); +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_AdvertisingPhase::supported_service() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.AdvertisingPhase.supported_service) + return _internal_supported_service(); +} +inline void ConnectionsLog_AdvertisingPhase::_internal_set_supported_service(::location::nearby::proto::connections::SupportedService value) { + assert(::location::nearby::proto::connections::SupportedService_IsValid(value)); + _has_bits_[0] |= 0x00000020u; + supported_service_ = value; +} +inline void ConnectionsLog_AdvertisingPhase::set_supported_service(::location::nearby::proto::connections::SupportedService value) { + _internal_set_supported_service(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.AdvertisingPhase.supported_service) +} + // ------------------------------------------------------------------- // ConnectionsLog_ConnectionRequest @@ -8329,6 +8719,91 @@ inline void ConnectionsLog_ConnectionAttempt::set_device_type(::location::nearby // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.device_type) } +// optional .location.nearby.proto.connections.SupportedService supported_service = 12; +inline bool ConnectionsLog_ConnectionAttempt::_internal_has_supported_service() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool ConnectionsLog_ConnectionAttempt::has_supported_service() const { + return _internal_has_supported_service(); +} +inline void ConnectionsLog_ConnectionAttempt::clear_supported_service() { + supported_service_ = 0; + _has_bits_[0] &= ~0x00002000u; +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_ConnectionAttempt::_internal_supported_service() const { + return static_cast< ::location::nearby::proto::connections::SupportedService >(supported_service_); +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_ConnectionAttempt::supported_service() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.supported_service) + return _internal_supported_service(); +} +inline void ConnectionsLog_ConnectionAttempt::_internal_set_supported_service(::location::nearby::proto::connections::SupportedService value) { + assert(::location::nearby::proto::connections::SupportedService_IsValid(value)); + _has_bits_[0] |= 0x00002000u; + supported_service_ = value; +} +inline void ConnectionsLog_ConnectionAttempt::set_supported_service(::location::nearby::proto::connections::SupportedService value) { + _internal_set_supported_service(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.supported_service) +} + +// optional int64 wifi_connection_latency_millis = 13; +inline bool ConnectionsLog_ConnectionAttempt::_internal_has_wifi_connection_latency_millis() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool ConnectionsLog_ConnectionAttempt::has_wifi_connection_latency_millis() const { + return _internal_has_wifi_connection_latency_millis(); +} +inline void ConnectionsLog_ConnectionAttempt::clear_wifi_connection_latency_millis() { + wifi_connection_latency_millis_ = int64_t{0}; + _has_bits_[0] &= ~0x00000800u; +} +inline int64_t ConnectionsLog_ConnectionAttempt::_internal_wifi_connection_latency_millis() const { + return wifi_connection_latency_millis_; +} +inline int64_t ConnectionsLog_ConnectionAttempt::wifi_connection_latency_millis() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.wifi_connection_latency_millis) + return _internal_wifi_connection_latency_millis(); +} +inline void ConnectionsLog_ConnectionAttempt::_internal_set_wifi_connection_latency_millis(int64_t value) { + _has_bits_[0] |= 0x00000800u; + wifi_connection_latency_millis_ = value; +} +inline void ConnectionsLog_ConnectionAttempt::set_wifi_connection_latency_millis(int64_t value) { + _internal_set_wifi_connection_latency_millis(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.wifi_connection_latency_millis) +} + +// optional int64 device_attestation_latency_millis = 14; +inline bool ConnectionsLog_ConnectionAttempt::_internal_has_device_attestation_latency_millis() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool ConnectionsLog_ConnectionAttempt::has_device_attestation_latency_millis() const { + return _internal_has_device_attestation_latency_millis(); +} +inline void ConnectionsLog_ConnectionAttempt::clear_device_attestation_latency_millis() { + device_attestation_latency_millis_ = int64_t{0}; + _has_bits_[0] &= ~0x00001000u; +} +inline int64_t ConnectionsLog_ConnectionAttempt::_internal_device_attestation_latency_millis() const { + return device_attestation_latency_millis_; +} +inline int64_t ConnectionsLog_ConnectionAttempt::device_attestation_latency_millis() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.device_attestation_latency_millis) + return _internal_device_attestation_latency_millis(); +} +inline void ConnectionsLog_ConnectionAttempt::_internal_set_device_attestation_latency_millis(int64_t value) { + _has_bits_[0] |= 0x00001000u; + device_attestation_latency_millis_ = value; +} +inline void ConnectionsLog_ConnectionAttempt::set_device_attestation_latency_millis(int64_t value) { + _internal_set_device_attestation_latency_millis(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.ConnectionAttempt.device_attestation_latency_millis) +} + // ------------------------------------------------------------------- // ConnectionsLog_DeviceInfo @@ -9254,13 +9729,187 @@ inline void ConnectionsLog_EstablishedConnection::set_device_type(::location::ne // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.device_type) } +// optional .location.nearby.proto.connections.SupportedService supported_service = 14; +inline bool ConnectionsLog_EstablishedConnection::_internal_has_supported_service() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool ConnectionsLog_EstablishedConnection::has_supported_service() const { + return _internal_has_supported_service(); +} +inline void ConnectionsLog_EstablishedConnection::clear_supported_service() { + supported_service_ = 0; + _has_bits_[0] &= ~0x00000800u; +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_EstablishedConnection::_internal_supported_service() const { + return static_cast< ::location::nearby::proto::connections::SupportedService >(supported_service_); +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_EstablishedConnection::supported_service() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.supported_service) + return _internal_supported_service(); +} +inline void ConnectionsLog_EstablishedConnection::_internal_set_supported_service(::location::nearby::proto::connections::SupportedService value) { + assert(::location::nearby::proto::connections::SupportedService_IsValid(value)); + _has_bits_[0] |= 0x00000800u; + supported_service_ = value; +} +inline void ConnectionsLog_EstablishedConnection::set_supported_service(::location::nearby::proto::connections::SupportedService value) { + _internal_set_supported_service(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.EstablishedConnection.supported_service) +} + +// ------------------------------------------------------------------- + +// ConnectionsLog_DctPayloadTransferStats + +// optional .location.nearby.proto.connections.DctPayloadType type = 1; +inline bool ConnectionsLog_DctPayloadTransferStats::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ConnectionsLog_DctPayloadTransferStats::has_type() const { + return _internal_has_type(); +} +inline void ConnectionsLog_DctPayloadTransferStats::clear_type() { + type_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::location::nearby::proto::connections::DctPayloadType ConnectionsLog_DctPayloadTransferStats::_internal_type() const { + return static_cast< ::location::nearby::proto::connections::DctPayloadType >(type_); +} +inline ::location::nearby::proto::connections::DctPayloadType ConnectionsLog_DctPayloadTransferStats::type() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.type) + return _internal_type(); +} +inline void ConnectionsLog_DctPayloadTransferStats::_internal_set_type(::location::nearby::proto::connections::DctPayloadType value) { + assert(::location::nearby::proto::connections::DctPayloadType_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + type_ = value; +} +inline void ConnectionsLog_DctPayloadTransferStats::set_type(::location::nearby::proto::connections::DctPayloadType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.type) +} + +// optional bool is_multipart = 2; +inline bool ConnectionsLog_DctPayloadTransferStats::_internal_has_is_multipart() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ConnectionsLog_DctPayloadTransferStats::has_is_multipart() const { + return _internal_has_is_multipart(); +} +inline void ConnectionsLog_DctPayloadTransferStats::clear_is_multipart() { + is_multipart_ = false; + _has_bits_[0] &= ~0x00000004u; +} +inline bool ConnectionsLog_DctPayloadTransferStats::_internal_is_multipart() const { + return is_multipart_; +} +inline bool ConnectionsLog_DctPayloadTransferStats::is_multipart() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.is_multipart) + return _internal_is_multipart(); +} +inline void ConnectionsLog_DctPayloadTransferStats::_internal_set_is_multipart(bool value) { + _has_bits_[0] |= 0x00000004u; + is_multipart_ = value; +} +inline void ConnectionsLog_DctPayloadTransferStats::set_is_multipart(bool value) { + _internal_set_is_multipart(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.is_multipart) +} + +// optional int32 num_parts_success = 3; +inline bool ConnectionsLog_DctPayloadTransferStats::_internal_has_num_parts_success() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ConnectionsLog_DctPayloadTransferStats::has_num_parts_success() const { + return _internal_has_num_parts_success(); +} +inline void ConnectionsLog_DctPayloadTransferStats::clear_num_parts_success() { + num_parts_success_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t ConnectionsLog_DctPayloadTransferStats::_internal_num_parts_success() const { + return num_parts_success_; +} +inline int32_t ConnectionsLog_DctPayloadTransferStats::num_parts_success() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.num_parts_success) + return _internal_num_parts_success(); +} +inline void ConnectionsLog_DctPayloadTransferStats::_internal_set_num_parts_success(int32_t value) { + _has_bits_[0] |= 0x00000002u; + num_parts_success_ = value; +} +inline void ConnectionsLog_DctPayloadTransferStats::set_num_parts_success(int32_t value) { + _internal_set_num_parts_success(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.num_parts_success) +} + +// optional int32 num_parts_failure = 4; +inline bool ConnectionsLog_DctPayloadTransferStats::_internal_has_num_parts_failure() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool ConnectionsLog_DctPayloadTransferStats::has_num_parts_failure() const { + return _internal_has_num_parts_failure(); +} +inline void ConnectionsLog_DctPayloadTransferStats::clear_num_parts_failure() { + num_parts_failure_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline int32_t ConnectionsLog_DctPayloadTransferStats::_internal_num_parts_failure() const { + return num_parts_failure_; +} +inline int32_t ConnectionsLog_DctPayloadTransferStats::num_parts_failure() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.num_parts_failure) + return _internal_num_parts_failure(); +} +inline void ConnectionsLog_DctPayloadTransferStats::_internal_set_num_parts_failure(int32_t value) { + _has_bits_[0] |= 0x00000010u; + num_parts_failure_ = value; +} +inline void ConnectionsLog_DctPayloadTransferStats::set_num_parts_failure(int32_t value) { + _internal_set_num_parts_failure(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.num_parts_failure) +} + +// optional bool is_resumption = 5; +inline bool ConnectionsLog_DctPayloadTransferStats::_internal_has_is_resumption() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ConnectionsLog_DctPayloadTransferStats::has_is_resumption() const { + return _internal_has_is_resumption(); +} +inline void ConnectionsLog_DctPayloadTransferStats::clear_is_resumption() { + is_resumption_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool ConnectionsLog_DctPayloadTransferStats::_internal_is_resumption() const { + return is_resumption_; +} +inline bool ConnectionsLog_DctPayloadTransferStats::is_resumption() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.is_resumption) + return _internal_is_resumption(); +} +inline void ConnectionsLog_DctPayloadTransferStats::_internal_set_is_resumption(bool value) { + _has_bits_[0] |= 0x00000008u; + is_resumption_ = value; +} +inline void ConnectionsLog_DctPayloadTransferStats::set_is_resumption(bool value) { + _internal_set_is_resumption(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats.is_resumption) +} + // ------------------------------------------------------------------- // ConnectionsLog_Payload // optional int64 duration_millis = 1; inline bool ConnectionsLog_Payload::_internal_has_duration_millis() const { - bool value = (_has_bits_[0] & 0x00000002u) != 0; + bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool ConnectionsLog_Payload::has_duration_millis() const { @@ -9268,7 +9917,7 @@ inline bool ConnectionsLog_Payload::has_duration_millis() const { } inline void ConnectionsLog_Payload::clear_duration_millis() { duration_millis_ = int64_t{0}; - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000004u; } inline int64_t ConnectionsLog_Payload::_internal_duration_millis() const { return duration_millis_; @@ -9278,7 +9927,7 @@ inline int64_t ConnectionsLog_Payload::duration_millis() const { return _internal_duration_millis(); } inline void ConnectionsLog_Payload::_internal_set_duration_millis(int64_t value) { - _has_bits_[0] |= 0x00000002u; + _has_bits_[0] |= 0x00000004u; duration_millis_ = value; } inline void ConnectionsLog_Payload::set_duration_millis(int64_t value) { @@ -9288,7 +9937,7 @@ inline void ConnectionsLog_Payload::set_duration_millis(int64_t value) { // optional .location.nearby.proto.connections.PayloadType type = 2; inline bool ConnectionsLog_Payload::_internal_has_type() const { - bool value = (_has_bits_[0] & 0x00000008u) != 0; + bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool ConnectionsLog_Payload::has_type() const { @@ -9296,7 +9945,7 @@ inline bool ConnectionsLog_Payload::has_type() const { } inline void ConnectionsLog_Payload::clear_type() { type_ = 0; - _has_bits_[0] &= ~0x00000008u; + _has_bits_[0] &= ~0x00000010u; } inline ::location::nearby::proto::connections::PayloadType ConnectionsLog_Payload::_internal_type() const { return static_cast< ::location::nearby::proto::connections::PayloadType >(type_); @@ -9307,7 +9956,7 @@ inline ::location::nearby::proto::connections::PayloadType ConnectionsLog_Payloa } inline void ConnectionsLog_Payload::_internal_set_type(::location::nearby::proto::connections::PayloadType value) { assert(::location::nearby::proto::connections::PayloadType_IsValid(value)); - _has_bits_[0] |= 0x00000008u; + _has_bits_[0] |= 0x00000010u; type_ = value; } inline void ConnectionsLog_Payload::set_type(::location::nearby::proto::connections::PayloadType value) { @@ -9317,7 +9966,7 @@ inline void ConnectionsLog_Payload::set_type(::location::nearby::proto::connecti // optional int64 total_size_bytes = 3; inline bool ConnectionsLog_Payload::_internal_has_total_size_bytes() const { - bool value = (_has_bits_[0] & 0x00000004u) != 0; + bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool ConnectionsLog_Payload::has_total_size_bytes() const { @@ -9325,7 +9974,7 @@ inline bool ConnectionsLog_Payload::has_total_size_bytes() const { } inline void ConnectionsLog_Payload::clear_total_size_bytes() { total_size_bytes_ = int64_t{0}; - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000008u; } inline int64_t ConnectionsLog_Payload::_internal_total_size_bytes() const { return total_size_bytes_; @@ -9335,7 +9984,7 @@ inline int64_t ConnectionsLog_Payload::total_size_bytes() const { return _internal_total_size_bytes(); } inline void ConnectionsLog_Payload::_internal_set_total_size_bytes(int64_t value) { - _has_bits_[0] |= 0x00000004u; + _has_bits_[0] |= 0x00000008u; total_size_bytes_ = value; } inline void ConnectionsLog_Payload::set_total_size_bytes(int64_t value) { @@ -9345,7 +9994,7 @@ inline void ConnectionsLog_Payload::set_total_size_bytes(int64_t value) { // optional int64 num_bytes_transferred = 4; inline bool ConnectionsLog_Payload::_internal_has_num_bytes_transferred() const { - bool value = (_has_bits_[0] & 0x00000020u) != 0; + bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool ConnectionsLog_Payload::has_num_bytes_transferred() const { @@ -9353,7 +10002,7 @@ inline bool ConnectionsLog_Payload::has_num_bytes_transferred() const { } inline void ConnectionsLog_Payload::clear_num_bytes_transferred() { num_bytes_transferred_ = int64_t{0}; - _has_bits_[0] &= ~0x00000020u; + _has_bits_[0] &= ~0x00000040u; } inline int64_t ConnectionsLog_Payload::_internal_num_bytes_transferred() const { return num_bytes_transferred_; @@ -9363,7 +10012,7 @@ inline int64_t ConnectionsLog_Payload::num_bytes_transferred() const { return _internal_num_bytes_transferred(); } inline void ConnectionsLog_Payload::_internal_set_num_bytes_transferred(int64_t value) { - _has_bits_[0] |= 0x00000020u; + _has_bits_[0] |= 0x00000040u; num_bytes_transferred_ = value; } inline void ConnectionsLog_Payload::set_num_bytes_transferred(int64_t value) { @@ -9373,7 +10022,7 @@ inline void ConnectionsLog_Payload::set_num_bytes_transferred(int64_t value) { // optional int32 num_chunks = 5; inline bool ConnectionsLog_Payload::_internal_has_num_chunks() const { - bool value = (_has_bits_[0] & 0x00000010u) != 0; + bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool ConnectionsLog_Payload::has_num_chunks() const { @@ -9381,7 +10030,7 @@ inline bool ConnectionsLog_Payload::has_num_chunks() const { } inline void ConnectionsLog_Payload::clear_num_chunks() { num_chunks_ = 0; - _has_bits_[0] &= ~0x00000010u; + _has_bits_[0] &= ~0x00000020u; } inline int32_t ConnectionsLog_Payload::_internal_num_chunks() const { return num_chunks_; @@ -9391,7 +10040,7 @@ inline int32_t ConnectionsLog_Payload::num_chunks() const { return _internal_num_chunks(); } inline void ConnectionsLog_Payload::_internal_set_num_chunks(int32_t value) { - _has_bits_[0] |= 0x00000010u; + _has_bits_[0] |= 0x00000020u; num_chunks_ = value; } inline void ConnectionsLog_Payload::set_num_chunks(int32_t value) { @@ -9401,7 +10050,7 @@ inline void ConnectionsLog_Payload::set_num_chunks(int32_t value) { // optional .location.nearby.proto.connections.PayloadStatus status = 6; inline bool ConnectionsLog_Payload::_internal_has_status() const { - bool value = (_has_bits_[0] & 0x00000040u) != 0; + bool value = (_has_bits_[0] & 0x00000080u) != 0; return value; } inline bool ConnectionsLog_Payload::has_status() const { @@ -9409,7 +10058,7 @@ inline bool ConnectionsLog_Payload::has_status() const { } inline void ConnectionsLog_Payload::clear_status() { status_ = 0; - _has_bits_[0] &= ~0x00000040u; + _has_bits_[0] &= ~0x00000080u; } inline ::location::nearby::proto::connections::PayloadStatus ConnectionsLog_Payload::_internal_status() const { return static_cast< ::location::nearby::proto::connections::PayloadStatus >(status_); @@ -9420,7 +10069,7 @@ inline ::location::nearby::proto::connections::PayloadStatus ConnectionsLog_Payl } inline void ConnectionsLog_Payload::_internal_set_status(::location::nearby::proto::connections::PayloadStatus value) { assert(::location::nearby::proto::connections::PayloadStatus_IsValid(value)); - _has_bits_[0] |= 0x00000040u; + _has_bits_[0] |= 0x00000080u; status_ = value; } inline void ConnectionsLog_Payload::set_status(::location::nearby::proto::connections::PayloadStatus value) { @@ -9430,7 +10079,7 @@ inline void ConnectionsLog_Payload::set_status(::location::nearby::proto::connec // optional int32 num_successful_auto_resume = 7; inline bool ConnectionsLog_Payload::_internal_has_num_successful_auto_resume() const { - bool value = (_has_bits_[0] & 0x00000080u) != 0; + bool value = (_has_bits_[0] & 0x00000100u) != 0; return value; } inline bool ConnectionsLog_Payload::has_num_successful_auto_resume() const { @@ -9438,7 +10087,7 @@ inline bool ConnectionsLog_Payload::has_num_successful_auto_resume() const { } inline void ConnectionsLog_Payload::clear_num_successful_auto_resume() { num_successful_auto_resume_ = 0; - _has_bits_[0] &= ~0x00000080u; + _has_bits_[0] &= ~0x00000100u; } inline int32_t ConnectionsLog_Payload::_internal_num_successful_auto_resume() const { return num_successful_auto_resume_; @@ -9448,7 +10097,7 @@ inline int32_t ConnectionsLog_Payload::num_successful_auto_resume() const { return _internal_num_successful_auto_resume(); } inline void ConnectionsLog_Payload::_internal_set_num_successful_auto_resume(int32_t value) { - _has_bits_[0] |= 0x00000080u; + _has_bits_[0] |= 0x00000100u; num_successful_auto_resume_ = value; } inline void ConnectionsLog_Payload::set_num_successful_auto_resume(int32_t value) { @@ -9548,7 +10197,7 @@ inline void ConnectionsLog_Payload::set_allocated_operation_result(::location::n // optional int32 num_failed_auto_resume = 9; inline bool ConnectionsLog_Payload::_internal_has_num_failed_auto_resume() const { - bool value = (_has_bits_[0] & 0x00000100u) != 0; + bool value = (_has_bits_[0] & 0x00000200u) != 0; return value; } inline bool ConnectionsLog_Payload::has_num_failed_auto_resume() const { @@ -9556,7 +10205,7 @@ inline bool ConnectionsLog_Payload::has_num_failed_auto_resume() const { } inline void ConnectionsLog_Payload::clear_num_failed_auto_resume() { num_failed_auto_resume_ = 0; - _has_bits_[0] &= ~0x00000100u; + _has_bits_[0] &= ~0x00000200u; } inline int32_t ConnectionsLog_Payload::_internal_num_failed_auto_resume() const { return num_failed_auto_resume_; @@ -9566,7 +10215,7 @@ inline int32_t ConnectionsLog_Payload::num_failed_auto_resume() const { return _internal_num_failed_auto_resume(); } inline void ConnectionsLog_Payload::_internal_set_num_failed_auto_resume(int32_t value) { - _has_bits_[0] |= 0x00000100u; + _has_bits_[0] |= 0x00000200u; num_failed_auto_resume_ = value; } inline void ConnectionsLog_Payload::set_num_failed_auto_resume(int32_t value) { @@ -9574,6 +10223,96 @@ inline void ConnectionsLog_Payload::set_num_failed_auto_resume(int32_t value) { // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.Payload.num_failed_auto_resume) } +// optional .location.nearby.analytics.proto.ConnectionsLog.DctPayloadTransferStats dct_payload_transfer_stats = 10; +inline bool ConnectionsLog_Payload::_internal_has_dct_payload_transfer_stats() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || dct_payload_transfer_stats_ != nullptr); + return value; +} +inline bool ConnectionsLog_Payload::has_dct_payload_transfer_stats() const { + return _internal_has_dct_payload_transfer_stats(); +} +inline void ConnectionsLog_Payload::clear_dct_payload_transfer_stats() { + if (dct_payload_transfer_stats_ != nullptr) dct_payload_transfer_stats_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats& ConnectionsLog_Payload::_internal_dct_payload_transfer_stats() const { + const ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* p = dct_payload_transfer_stats_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::analytics::proto::_ConnectionsLog_DctPayloadTransferStats_default_instance_); +} +inline const ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats& ConnectionsLog_Payload::dct_payload_transfer_stats() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.Payload.dct_payload_transfer_stats) + return _internal_dct_payload_transfer_stats(); +} +inline void ConnectionsLog_Payload::unsafe_arena_set_allocated_dct_payload_transfer_stats( + ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* dct_payload_transfer_stats) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dct_payload_transfer_stats_); + } + dct_payload_transfer_stats_ = dct_payload_transfer_stats; + if (dct_payload_transfer_stats) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.analytics.proto.ConnectionsLog.Payload.dct_payload_transfer_stats) +} +inline ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* ConnectionsLog_Payload::release_dct_payload_transfer_stats() { + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* temp = dct_payload_transfer_stats_; + dct_payload_transfer_stats_ = 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::analytics::proto::ConnectionsLog_DctPayloadTransferStats* ConnectionsLog_Payload::unsafe_arena_release_dct_payload_transfer_stats() { + // @@protoc_insertion_point(field_release:location.nearby.analytics.proto.ConnectionsLog.Payload.dct_payload_transfer_stats) + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* temp = dct_payload_transfer_stats_; + dct_payload_transfer_stats_ = nullptr; + return temp; +} +inline ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* ConnectionsLog_Payload::_internal_mutable_dct_payload_transfer_stats() { + _has_bits_[0] |= 0x00000002u; + if (dct_payload_transfer_stats_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats>(GetArenaForAllocation()); + dct_payload_transfer_stats_ = p; + } + return dct_payload_transfer_stats_; +} +inline ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* ConnectionsLog_Payload::mutable_dct_payload_transfer_stats() { + ::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* _msg = _internal_mutable_dct_payload_transfer_stats(); + // @@protoc_insertion_point(field_mutable:location.nearby.analytics.proto.ConnectionsLog.Payload.dct_payload_transfer_stats) + return _msg; +} +inline void ConnectionsLog_Payload::set_allocated_dct_payload_transfer_stats(::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats* dct_payload_transfer_stats) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete dct_payload_transfer_stats_; + } + if (dct_payload_transfer_stats) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::analytics::proto::ConnectionsLog_DctPayloadTransferStats>::GetOwningArena(dct_payload_transfer_stats); + if (message_arena != submessage_arena) { + dct_payload_transfer_stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, dct_payload_transfer_stats, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + dct_payload_transfer_stats_ = dct_payload_transfer_stats; + // @@protoc_insertion_point(field_set_allocated:location.nearby.analytics.proto.ConnectionsLog.Payload.dct_payload_transfer_stats) +} + // ------------------------------------------------------------------- // ConnectionsLog_BandwidthUpgradeAttempt @@ -9967,6 +10706,35 @@ inline void ConnectionsLog_BandwidthUpgradeAttempt::set_device_type(::location:: // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt.device_type) } +// optional .location.nearby.proto.connections.SupportedService supported_service = 11; +inline bool ConnectionsLog_BandwidthUpgradeAttempt::_internal_has_supported_service() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool ConnectionsLog_BandwidthUpgradeAttempt::has_supported_service() const { + return _internal_has_supported_service(); +} +inline void ConnectionsLog_BandwidthUpgradeAttempt::clear_supported_service() { + supported_service_ = 0; + _has_bits_[0] &= ~0x00000400u; +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_BandwidthUpgradeAttempt::_internal_supported_service() const { + return static_cast< ::location::nearby::proto::connections::SupportedService >(supported_service_); +} +inline ::location::nearby::proto::connections::SupportedService ConnectionsLog_BandwidthUpgradeAttempt::supported_service() const { + // @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt.supported_service) + return _internal_supported_service(); +} +inline void ConnectionsLog_BandwidthUpgradeAttempt::_internal_set_supported_service(::location::nearby::proto::connections::SupportedService value) { + assert(::location::nearby::proto::connections::SupportedService_IsValid(value)); + _has_bits_[0] |= 0x00000400u; + supported_service_ = value; +} +inline void ConnectionsLog_BandwidthUpgradeAttempt::set_supported_service(::location::nearby::proto::connections::SupportedService value) { + _internal_set_supported_service(value); + // @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.BandwidthUpgradeAttempt.supported_service) +} + // ------------------------------------------------------------------- // ConnectionsLog_ErrorCode @@ -12085,6 +12853,8 @@ inline void ConnectionsLog::set_allocated_files_migration_phase(std::string* fil // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/compiled_proto/proto/connections_enums.pb.cc b/compiled_proto/proto/connections_enums.pb.cc index 610bcb58..72d709fa 100644 --- a/compiled_proto/proto/connections_enums.pb.cc +++ b/compiled_proto/proto/connections_enums.pb.cc @@ -316,6 +316,61 @@ bool Medium_Parse( } return success; } +bool WifiDirectAuthType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed WifiDirectAuthType_strings[3] = {}; + +static const char WifiDirectAuthType_names[] = + "WIFI_DIRECT_TYPE_UNKNOWN" + "WIFI_DIRECT_WITH_PASSWORD" + "WIFI_DIRECT_WITH_PIN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry WifiDirectAuthType_entries[] = { + { {WifiDirectAuthType_names + 0, 24}, 0 }, + { {WifiDirectAuthType_names + 24, 25}, 1 }, + { {WifiDirectAuthType_names + 49, 20}, 2 }, +}; + +static const int WifiDirectAuthType_entries_by_number[] = { + 0, // 0 -> WIFI_DIRECT_TYPE_UNKNOWN + 1, // 1 -> WIFI_DIRECT_WITH_PASSWORD + 2, // 2 -> WIFI_DIRECT_WITH_PIN +}; + +const std::string& WifiDirectAuthType_Name( + WifiDirectAuthType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + WifiDirectAuthType_entries, + WifiDirectAuthType_entries_by_number, + 3, WifiDirectAuthType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + WifiDirectAuthType_entries, + WifiDirectAuthType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + WifiDirectAuthType_strings[idx].get(); +} +bool WifiDirectAuthType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WifiDirectAuthType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + WifiDirectAuthType_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} bool ConnectionTechnology_IsValid(int value) { switch (value) { case 0: @@ -1908,6 +1963,10 @@ bool OperationResultCode_IsValid(int value) { case 3604: case 3605: case 3606: + case 3607: + case 3608: + case 3609: + case 3610: case 4500: case 4501: case 4502: @@ -2052,7 +2111,7 @@ bool OperationResultCode_IsValid(int value) { } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed OperationResultCode_strings[397] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed OperationResultCode_strings[401] = {}; static const char OperationResultCode_names[] = "CLIENT_ALREADY_CONNECTED_TO_ENDPOINT" @@ -2193,9 +2252,13 @@ static const char OperationResultCode_names[] = "CONNECTIVITY_WIFI_AWARE_ATTACH_FAILURE" "CONNECTIVITY_WIFI_AWARE_CLIENT_SOCKET_CREATION_FAILURE" "CONNECTIVITY_WIFI_AWARE_DISCOVERED_PEER_NULL" + "CONNECTIVITY_WIFI_AWARE_DISCOVER_PEER_NULL_SCREEN_OFF" + "CONNECTIVITY_WIFI_AWARE_DISCOVER_PEER_NULL_TIMEOUT" + "CONNECTIVITY_WIFI_AWARE_DO_UNAVAILABLE" "CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_ADDRESS_FAILURE" "CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_FRAME_FAILURE" "CONNECTIVITY_WIFI_AWARE_INVALID_CREDENTIAL" + "CONNECTIVITY_WIFI_AWARE_JOIN_NETWORK_FAILED" "CONNECTIVITY_WIFI_AWARE_L2MESSAGE_NETWORK_AVAILABLE_FRAME_NULL" "CONNECTIVITY_WIFI_AWARE_L2MESSAGE_SEND_HOST_NETWORK_FRAME_FAILURE" "CONNECTIVITY_WIFI_AWARE_SERVER_SOCKET_CREATION_FAILURE" @@ -2592,270 +2655,274 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OperationResultCode_en { {OperationResultCode_names + 5963, 38}, 3500 }, { {OperationResultCode_names + 6001, 54}, 3508 }, { {OperationResultCode_names + 6055, 44}, 3552 }, - { {OperationResultCode_names + 6099, 53}, 3515 }, - { {OperationResultCode_names + 6152, 51}, 3514 }, - { {OperationResultCode_names + 6203, 42}, 3522 }, - { {OperationResultCode_names + 6245, 62}, 3527 }, - { {OperationResultCode_names + 6307, 65}, 3528 }, - { {OperationResultCode_names + 6372, 54}, 3544 }, - { {OperationResultCode_names + 6426, 49}, 3589 }, - { {OperationResultCode_names + 6475, 47}, 3595 }, - { {OperationResultCode_names + 6522, 46}, 3549 }, - { {OperationResultCode_names + 6568, 55}, 3510 }, - { {OperationResultCode_names + 6623, 55}, 3532 }, - { {OperationResultCode_names + 6678, 54}, 3516 }, - { {OperationResultCode_names + 6732, 43}, 3520 }, - { {OperationResultCode_names + 6775, 55}, 3535 }, - { {OperationResultCode_names + 6830, 47}, 3575 }, - { {OperationResultCode_names + 6877, 51}, 3537 }, - { {OperationResultCode_names + 6928, 55}, 3546 }, - { {OperationResultCode_names + 6983, 56}, 3509 }, - { {OperationResultCode_names + 7039, 56}, 3533 }, - { {OperationResultCode_names + 7095, 55}, 3517 }, - { {OperationResultCode_names + 7150, 44}, 3521 }, - { {OperationResultCode_names + 7194, 55}, 3581 }, - { {OperationResultCode_names + 7249, 47}, 3530 }, - { {OperationResultCode_names + 7296, 56}, 3534 }, - { {OperationResultCode_names + 7352, 52}, 3536 }, - { {OperationResultCode_names + 7404, 56}, 3545 }, - { {OperationResultCode_names + 7460, 50}, 3548 }, - { {OperationResultCode_names + 7510, 43}, 3580 }, - { {OperationResultCode_names + 7553, 40}, 3519 }, - { {OperationResultCode_names + 7593, 38}, 3524 }, - { {OperationResultCode_names + 7631, 49}, 3583 }, - { {OperationResultCode_names + 7680, 44}, 3582 }, - { {OperationResultCode_names + 7724, 47}, 3588 }, - { {OperationResultCode_names + 7771, 45}, 3594 }, - { {OperationResultCode_names + 7816, 24}, 5001 }, - { {OperationResultCode_names + 7840, 22}, 5000 }, - { {OperationResultCode_names + 7862, 25}, 5002 }, - { {OperationResultCode_names + 7887, 29}, 5012 }, - { {OperationResultCode_names + 7916, 34}, 5011 }, - { {OperationResultCode_names + 7950, 37}, 5020 }, - { {OperationResultCode_names + 7987, 39}, 5013 }, - { {OperationResultCode_names + 8026, 28}, 5024 }, - { {OperationResultCode_names + 8054, 27}, 5007 }, - { {OperationResultCode_names + 8081, 27}, 5019 }, - { {OperationResultCode_names + 8108, 29}, 5004 }, - { {OperationResultCode_names + 8137, 29}, 5003 }, - { {OperationResultCode_names + 8166, 32}, 5005 }, - { {OperationResultCode_names + 8198, 31}, 5006 }, - { {OperationResultCode_names + 8229, 24}, 5009 }, - { {OperationResultCode_names + 8253, 25}, 5010 }, - { {OperationResultCode_names + 8278, 27}, 5022 }, - { {OperationResultCode_names + 8305, 30}, 5008 }, - { {OperationResultCode_names + 8335, 30}, 5023 }, - { {OperationResultCode_names + 8365, 42}, 5018 }, - { {OperationResultCode_names + 8407, 24}, 5021 }, - { {OperationResultCode_names + 8431, 34}, 5016 }, - { {OperationResultCode_names + 8465, 23}, 5014 }, - { {OperationResultCode_names + 8488, 27}, 5015 }, - { {OperationResultCode_names + 8515, 34}, 5017 }, - { {OperationResultCode_names + 8549, 14}, 1 }, - { {OperationResultCode_names + 8563, 14}, 0 }, - { {OperationResultCode_names + 8577, 46}, 1000 }, - { {OperationResultCode_names + 8623, 39}, 1001 }, - { {OperationResultCode_names + 8662, 30}, 1002 }, - { {OperationResultCode_names + 8692, 36}, 1003 }, - { {OperationResultCode_names + 8728, 35}, 1004 }, - { {OperationResultCode_names + 8763, 27}, 3005 }, - { {OperationResultCode_names + 8790, 33}, 3006 }, - { {OperationResultCode_names + 8823, 26}, 3007 }, - { {OperationResultCode_names + 8849, 27}, 3009 }, - { {OperationResultCode_names + 8876, 27}, 3013 }, - { {OperationResultCode_names + 8903, 27}, 3014 }, - { {OperationResultCode_names + 8930, 31}, 3008 }, - { {OperationResultCode_names + 8961, 34}, 3012 }, - { {OperationResultCode_names + 8995, 35}, 3010 }, - { {OperationResultCode_names + 9030, 36}, 3011 }, - { {OperationResultCode_names + 9066, 21}, 3000 }, - { {OperationResultCode_names + 9087, 21}, 3001 }, - { {OperationResultCode_names + 9108, 21}, 3002 }, - { {OperationResultCode_names + 9129, 24}, 3003 }, - { {OperationResultCode_names + 9153, 29}, 3004 }, - { {OperationResultCode_names + 9182, 51}, 1534 }, - { {OperationResultCode_names + 9233, 60}, 1535 }, - { {OperationResultCode_names + 9293, 37}, 1547 }, - { {OperationResultCode_names + 9330, 47}, 1515 }, - { {OperationResultCode_names + 9377, 36}, 1505 }, - { {OperationResultCode_names + 9413, 42}, 1507 }, - { {OperationResultCode_names + 9455, 40}, 1546 }, - { {OperationResultCode_names + 9495, 46}, 1516 }, - { {OperationResultCode_names + 9541, 45}, 1501 }, - { {OperationResultCode_names + 9586, 45}, 1541 }, - { {OperationResultCode_names + 9631, 38}, 1506 }, - { {OperationResultCode_names + 9669, 30}, 1544 }, - { {OperationResultCode_names + 9699, 47}, 1517 }, - { {OperationResultCode_names + 9746, 36}, 1513 }, - { {OperationResultCode_names + 9782, 54}, 1532 }, - { {OperationResultCode_names + 9836, 49}, 1503 }, - { {OperationResultCode_names + 9885, 52}, 1504 }, - { {OperationResultCode_names + 9937, 37}, 1543 }, - { {OperationResultCode_names + 9974, 47}, 1518 }, - { {OperationResultCode_names + 10021, 36}, 1512 }, - { {OperationResultCode_names + 10057, 36}, 1542 }, - { {OperationResultCode_names + 10093, 30}, 1545 }, - { {OperationResultCode_names + 10123, 60}, 1536 }, - { {OperationResultCode_names + 10183, 43}, 1533 }, - { {OperationResultCode_names + 10226, 38}, 1502 }, - { {OperationResultCode_names + 10264, 39}, 1539 }, - { {OperationResultCode_names + 10303, 37}, 1540 }, - { {OperationResultCode_names + 10340, 41}, 1537 }, - { {OperationResultCode_names + 10381, 55}, 1526 }, - { {OperationResultCode_names + 10436, 54}, 1530 }, - { {OperationResultCode_names + 10490, 57}, 1527 }, - { {OperationResultCode_names + 10547, 55}, 1529 }, - { {OperationResultCode_names + 10602, 55}, 1531 }, - { {OperationResultCode_names + 10657, 59}, 1528 }, - { {OperationResultCode_names + 10716, 47}, 1519 }, - { {OperationResultCode_names + 10763, 36}, 1514 }, - { {OperationResultCode_names + 10799, 51}, 1520 }, - { {OperationResultCode_names + 10850, 40}, 1508 }, - { {OperationResultCode_names + 10890, 38}, 1538 }, - { {OperationResultCode_names + 10928, 54}, 1521 }, - { {OperationResultCode_names + 10982, 43}, 1509 }, - { {OperationResultCode_names + 11025, 52}, 1500 }, - { {OperationResultCode_names + 11077, 55}, 1523 }, - { {OperationResultCode_names + 11132, 44}, 1511 }, - { {OperationResultCode_names + 11176, 57}, 1525 }, - { {OperationResultCode_names + 11233, 56}, 1522 }, - { {OperationResultCode_names + 11289, 45}, 1510 }, - { {OperationResultCode_names + 11334, 58}, 1524 }, - { {OperationResultCode_names + 11392, 38}, 2503 }, - { {OperationResultCode_names + 11430, 51}, 2514 }, - { {OperationResultCode_names + 11481, 41}, 2500 }, - { {OperationResultCode_names + 11522, 59}, 2510 }, - { {OperationResultCode_names + 11581, 37}, 2505 }, - { {OperationResultCode_names + 11618, 40}, 2504 }, - { {OperationResultCode_names + 11658, 33}, 2501 }, - { {OperationResultCode_names + 11691, 48}, 2513 }, - { {OperationResultCode_names + 11739, 52}, 2511 }, - { {OperationResultCode_names + 11791, 38}, 2515 }, - { {OperationResultCode_names + 11829, 55}, 2512 }, - { {OperationResultCode_names + 11884, 45}, 2506 }, - { {OperationResultCode_names + 11929, 46}, 2507 }, - { {OperationResultCode_names + 11975, 56}, 2502 }, - { {OperationResultCode_names + 12031, 47}, 2509 }, - { {OperationResultCode_names + 12078, 43}, 2508 }, - { {OperationResultCode_names + 12121, 31}, 2516 }, - { {OperationResultCode_names + 12152, 29}, 4568 }, - { {OperationResultCode_names + 12181, 38}, 4611 }, - { {OperationResultCode_names + 12219, 45}, 4612 }, - { {OperationResultCode_names + 12264, 60}, 4609 }, - { {OperationResultCode_names + 12324, 45}, 4500 }, - { {OperationResultCode_names + 12369, 37}, 4571 }, - { {OperationResultCode_names + 12406, 44}, 4504 }, - { {OperationResultCode_names + 12450, 42}, 4572 }, - { {OperationResultCode_names + 12492, 49}, 4515 }, - { {OperationResultCode_names + 12541, 29}, 4518 }, - { {OperationResultCode_names + 12570, 30}, 4579 }, - { {OperationResultCode_names + 12600, 38}, 4536 }, - { {OperationResultCode_names + 12638, 43}, 4570 }, - { {OperationResultCode_names + 12681, 36}, 4578 }, - { {OperationResultCode_names + 12717, 48}, 4501 }, - { {OperationResultCode_names + 12765, 44}, 4585 }, - { {OperationResultCode_names + 12809, 35}, 4592 }, - { {OperationResultCode_names + 12844, 43}, 4506 }, - { {OperationResultCode_names + 12887, 35}, 4530 }, - { {OperationResultCode_names + 12922, 23}, 4520 }, - { {OperationResultCode_names + 12945, 37}, 4538 }, - { {OperationResultCode_names + 12982, 41}, 4563 }, - { {OperationResultCode_names + 13023, 37}, 4602 }, - { {OperationResultCode_names + 13060, 31}, 4610 }, - { {OperationResultCode_names + 13091, 38}, 4606 }, - { {OperationResultCode_names + 13129, 37}, 4591 }, - { {OperationResultCode_names + 13166, 25}, 4567 }, - { {OperationResultCode_names + 13191, 27}, 4605 }, - { {OperationResultCode_names + 13218, 32}, 4503 }, - { {OperationResultCode_names + 13250, 35}, 4514 }, - { {OperationResultCode_names + 13285, 48}, 4588 }, - { {OperationResultCode_names + 13333, 45}, 4552 }, - { {OperationResultCode_names + 13378, 40}, 4532 }, - { {OperationResultCode_names + 13418, 40}, 4535 }, - { {OperationResultCode_names + 13458, 48}, 4547 }, - { {OperationResultCode_names + 13506, 60}, 4556 }, - { {OperationResultCode_names + 13566, 56}, 4558 }, - { {OperationResultCode_names + 13622, 60}, 4557 }, - { {OperationResultCode_names + 13682, 56}, 4553 }, - { {OperationResultCode_names + 13738, 52}, 4555 }, - { {OperationResultCode_names + 13790, 56}, 4554 }, - { {OperationResultCode_names + 13846, 43}, 4559 }, - { {OperationResultCode_names + 13889, 43}, 4560 }, - { {OperationResultCode_names + 13932, 37}, 4561 }, - { {OperationResultCode_names + 13969, 41}, 4562 }, - { {OperationResultCode_names + 14010, 49}, 4586 }, - { {OperationResultCode_names + 14059, 46}, 4505 }, - { {OperationResultCode_names + 14105, 26}, 4519 }, - { {OperationResultCode_names + 14131, 40}, 4537 }, - { {OperationResultCode_names + 14171, 29}, 4566 }, - { {OperationResultCode_names + 14200, 44}, 4507 }, - { {OperationResultCode_names + 14244, 36}, 4531 }, - { {OperationResultCode_names + 14280, 24}, 4525 }, - { {OperationResultCode_names + 14304, 38}, 4539 }, - { {OperationResultCode_names + 14342, 41}, 4593 }, - { {OperationResultCode_names + 14383, 28}, 4594 }, - { {OperationResultCode_names + 14411, 42}, 4564 }, - { {OperationResultCode_names + 14453, 30}, 4569 }, - { {OperationResultCode_names + 14483, 31}, 4607 }, - { {OperationResultCode_names + 14514, 27}, 4587 }, - { {OperationResultCode_names + 14541, 37}, 4573 }, - { {OperationResultCode_names + 14578, 44}, 4508 }, - { {OperationResultCode_names + 14622, 30}, 4577 }, - { {OperationResultCode_names + 14652, 24}, 4522 }, - { {OperationResultCode_names + 14676, 35}, 4601 }, - { {OperationResultCode_names + 14711, 56}, 4608 }, - { {OperationResultCode_names + 14767, 29}, 4603 }, - { {OperationResultCode_names + 14796, 28}, 4604 }, - { {OperationResultCode_names + 14824, 35}, 4590 }, - { {OperationResultCode_names + 14859, 37}, 4576 }, - { {OperationResultCode_names + 14896, 44}, 4513 }, - { {OperationResultCode_names + 14940, 30}, 4582 }, - { {OperationResultCode_names + 14970, 24}, 4521 }, - { {OperationResultCode_names + 14994, 30}, 4583 }, - { {OperationResultCode_names + 15024, 35}, 4502 }, - { {OperationResultCode_names + 15059, 48}, 4512 }, - { {OperationResultCode_names + 15107, 34}, 4584 }, - { {OperationResultCode_names + 15141, 38}, 4589 }, - { {OperationResultCode_names + 15179, 28}, 4524 }, - { {OperationResultCode_names + 15207, 42}, 4540 }, - { {OperationResultCode_names + 15249, 37}, 4599 }, - { {OperationResultCode_names + 15286, 44}, 4575 }, - { {OperationResultCode_names + 15330, 51}, 4509 }, - { {OperationResultCode_names + 15381, 37}, 4581 }, - { {OperationResultCode_names + 15418, 31}, 4523 }, - { {OperationResultCode_names + 15449, 45}, 4541 }, - { {OperationResultCode_names + 15494, 42}, 4600 }, - { {OperationResultCode_names + 15536, 52}, 4511 }, - { {OperationResultCode_names + 15588, 39}, 4516 }, - { {OperationResultCode_names + 15627, 41}, 4533 }, - { {OperationResultCode_names + 15668, 32}, 4527 }, - { {OperationResultCode_names + 15700, 32}, 4529 }, - { {OperationResultCode_names + 15732, 28}, 4528 }, - { {OperationResultCode_names + 15760, 46}, 4546 }, - { {OperationResultCode_names + 15806, 48}, 4549 }, - { {OperationResultCode_names + 15854, 48}, 4551 }, - { {OperationResultCode_names + 15902, 51}, 4596 }, - { {OperationResultCode_names + 15953, 43}, 4595 }, - { {OperationResultCode_names + 15996, 54}, 4545 }, - { {OperationResultCode_names + 16050, 54}, 4542 }, - { {OperationResultCode_names + 16104, 53}, 4510 }, - { {OperationResultCode_names + 16157, 40}, 4517 }, - { {OperationResultCode_names + 16197, 52}, 4544 }, - { {OperationResultCode_names + 16249, 44}, 4534 }, - { {OperationResultCode_names + 16293, 33}, 4526 }, - { {OperationResultCode_names + 16326, 49}, 4548 }, - { {OperationResultCode_names + 16375, 49}, 4550 }, - { {OperationResultCode_names + 16424, 52}, 4598 }, - { {OperationResultCode_names + 16476, 44}, 4597 }, - { {OperationResultCode_names + 16520, 55}, 4543 }, - { {OperationResultCode_names + 16575, 42}, 4574 }, - { {OperationResultCode_names + 16617, 35}, 4580 }, - { {OperationResultCode_names + 16652, 32}, 4565 }, + { {OperationResultCode_names + 6099, 53}, 3608 }, + { {OperationResultCode_names + 6152, 50}, 3609 }, + { {OperationResultCode_names + 6202, 38}, 3607 }, + { {OperationResultCode_names + 6240, 53}, 3515 }, + { {OperationResultCode_names + 6293, 51}, 3514 }, + { {OperationResultCode_names + 6344, 42}, 3522 }, + { {OperationResultCode_names + 6386, 43}, 3610 }, + { {OperationResultCode_names + 6429, 62}, 3527 }, + { {OperationResultCode_names + 6491, 65}, 3528 }, + { {OperationResultCode_names + 6556, 54}, 3544 }, + { {OperationResultCode_names + 6610, 49}, 3589 }, + { {OperationResultCode_names + 6659, 47}, 3595 }, + { {OperationResultCode_names + 6706, 46}, 3549 }, + { {OperationResultCode_names + 6752, 55}, 3510 }, + { {OperationResultCode_names + 6807, 55}, 3532 }, + { {OperationResultCode_names + 6862, 54}, 3516 }, + { {OperationResultCode_names + 6916, 43}, 3520 }, + { {OperationResultCode_names + 6959, 55}, 3535 }, + { {OperationResultCode_names + 7014, 47}, 3575 }, + { {OperationResultCode_names + 7061, 51}, 3537 }, + { {OperationResultCode_names + 7112, 55}, 3546 }, + { {OperationResultCode_names + 7167, 56}, 3509 }, + { {OperationResultCode_names + 7223, 56}, 3533 }, + { {OperationResultCode_names + 7279, 55}, 3517 }, + { {OperationResultCode_names + 7334, 44}, 3521 }, + { {OperationResultCode_names + 7378, 55}, 3581 }, + { {OperationResultCode_names + 7433, 47}, 3530 }, + { {OperationResultCode_names + 7480, 56}, 3534 }, + { {OperationResultCode_names + 7536, 52}, 3536 }, + { {OperationResultCode_names + 7588, 56}, 3545 }, + { {OperationResultCode_names + 7644, 50}, 3548 }, + { {OperationResultCode_names + 7694, 43}, 3580 }, + { {OperationResultCode_names + 7737, 40}, 3519 }, + { {OperationResultCode_names + 7777, 38}, 3524 }, + { {OperationResultCode_names + 7815, 49}, 3583 }, + { {OperationResultCode_names + 7864, 44}, 3582 }, + { {OperationResultCode_names + 7908, 47}, 3588 }, + { {OperationResultCode_names + 7955, 45}, 3594 }, + { {OperationResultCode_names + 8000, 24}, 5001 }, + { {OperationResultCode_names + 8024, 22}, 5000 }, + { {OperationResultCode_names + 8046, 25}, 5002 }, + { {OperationResultCode_names + 8071, 29}, 5012 }, + { {OperationResultCode_names + 8100, 34}, 5011 }, + { {OperationResultCode_names + 8134, 37}, 5020 }, + { {OperationResultCode_names + 8171, 39}, 5013 }, + { {OperationResultCode_names + 8210, 28}, 5024 }, + { {OperationResultCode_names + 8238, 27}, 5007 }, + { {OperationResultCode_names + 8265, 27}, 5019 }, + { {OperationResultCode_names + 8292, 29}, 5004 }, + { {OperationResultCode_names + 8321, 29}, 5003 }, + { {OperationResultCode_names + 8350, 32}, 5005 }, + { {OperationResultCode_names + 8382, 31}, 5006 }, + { {OperationResultCode_names + 8413, 24}, 5009 }, + { {OperationResultCode_names + 8437, 25}, 5010 }, + { {OperationResultCode_names + 8462, 27}, 5022 }, + { {OperationResultCode_names + 8489, 30}, 5008 }, + { {OperationResultCode_names + 8519, 30}, 5023 }, + { {OperationResultCode_names + 8549, 42}, 5018 }, + { {OperationResultCode_names + 8591, 24}, 5021 }, + { {OperationResultCode_names + 8615, 34}, 5016 }, + { {OperationResultCode_names + 8649, 23}, 5014 }, + { {OperationResultCode_names + 8672, 27}, 5015 }, + { {OperationResultCode_names + 8699, 34}, 5017 }, + { {OperationResultCode_names + 8733, 14}, 1 }, + { {OperationResultCode_names + 8747, 14}, 0 }, + { {OperationResultCode_names + 8761, 46}, 1000 }, + { {OperationResultCode_names + 8807, 39}, 1001 }, + { {OperationResultCode_names + 8846, 30}, 1002 }, + { {OperationResultCode_names + 8876, 36}, 1003 }, + { {OperationResultCode_names + 8912, 35}, 1004 }, + { {OperationResultCode_names + 8947, 27}, 3005 }, + { {OperationResultCode_names + 8974, 33}, 3006 }, + { {OperationResultCode_names + 9007, 26}, 3007 }, + { {OperationResultCode_names + 9033, 27}, 3009 }, + { {OperationResultCode_names + 9060, 27}, 3013 }, + { {OperationResultCode_names + 9087, 27}, 3014 }, + { {OperationResultCode_names + 9114, 31}, 3008 }, + { {OperationResultCode_names + 9145, 34}, 3012 }, + { {OperationResultCode_names + 9179, 35}, 3010 }, + { {OperationResultCode_names + 9214, 36}, 3011 }, + { {OperationResultCode_names + 9250, 21}, 3000 }, + { {OperationResultCode_names + 9271, 21}, 3001 }, + { {OperationResultCode_names + 9292, 21}, 3002 }, + { {OperationResultCode_names + 9313, 24}, 3003 }, + { {OperationResultCode_names + 9337, 29}, 3004 }, + { {OperationResultCode_names + 9366, 51}, 1534 }, + { {OperationResultCode_names + 9417, 60}, 1535 }, + { {OperationResultCode_names + 9477, 37}, 1547 }, + { {OperationResultCode_names + 9514, 47}, 1515 }, + { {OperationResultCode_names + 9561, 36}, 1505 }, + { {OperationResultCode_names + 9597, 42}, 1507 }, + { {OperationResultCode_names + 9639, 40}, 1546 }, + { {OperationResultCode_names + 9679, 46}, 1516 }, + { {OperationResultCode_names + 9725, 45}, 1501 }, + { {OperationResultCode_names + 9770, 45}, 1541 }, + { {OperationResultCode_names + 9815, 38}, 1506 }, + { {OperationResultCode_names + 9853, 30}, 1544 }, + { {OperationResultCode_names + 9883, 47}, 1517 }, + { {OperationResultCode_names + 9930, 36}, 1513 }, + { {OperationResultCode_names + 9966, 54}, 1532 }, + { {OperationResultCode_names + 10020, 49}, 1503 }, + { {OperationResultCode_names + 10069, 52}, 1504 }, + { {OperationResultCode_names + 10121, 37}, 1543 }, + { {OperationResultCode_names + 10158, 47}, 1518 }, + { {OperationResultCode_names + 10205, 36}, 1512 }, + { {OperationResultCode_names + 10241, 36}, 1542 }, + { {OperationResultCode_names + 10277, 30}, 1545 }, + { {OperationResultCode_names + 10307, 60}, 1536 }, + { {OperationResultCode_names + 10367, 43}, 1533 }, + { {OperationResultCode_names + 10410, 38}, 1502 }, + { {OperationResultCode_names + 10448, 39}, 1539 }, + { {OperationResultCode_names + 10487, 37}, 1540 }, + { {OperationResultCode_names + 10524, 41}, 1537 }, + { {OperationResultCode_names + 10565, 55}, 1526 }, + { {OperationResultCode_names + 10620, 54}, 1530 }, + { {OperationResultCode_names + 10674, 57}, 1527 }, + { {OperationResultCode_names + 10731, 55}, 1529 }, + { {OperationResultCode_names + 10786, 55}, 1531 }, + { {OperationResultCode_names + 10841, 59}, 1528 }, + { {OperationResultCode_names + 10900, 47}, 1519 }, + { {OperationResultCode_names + 10947, 36}, 1514 }, + { {OperationResultCode_names + 10983, 51}, 1520 }, + { {OperationResultCode_names + 11034, 40}, 1508 }, + { {OperationResultCode_names + 11074, 38}, 1538 }, + { {OperationResultCode_names + 11112, 54}, 1521 }, + { {OperationResultCode_names + 11166, 43}, 1509 }, + { {OperationResultCode_names + 11209, 52}, 1500 }, + { {OperationResultCode_names + 11261, 55}, 1523 }, + { {OperationResultCode_names + 11316, 44}, 1511 }, + { {OperationResultCode_names + 11360, 57}, 1525 }, + { {OperationResultCode_names + 11417, 56}, 1522 }, + { {OperationResultCode_names + 11473, 45}, 1510 }, + { {OperationResultCode_names + 11518, 58}, 1524 }, + { {OperationResultCode_names + 11576, 38}, 2503 }, + { {OperationResultCode_names + 11614, 51}, 2514 }, + { {OperationResultCode_names + 11665, 41}, 2500 }, + { {OperationResultCode_names + 11706, 59}, 2510 }, + { {OperationResultCode_names + 11765, 37}, 2505 }, + { {OperationResultCode_names + 11802, 40}, 2504 }, + { {OperationResultCode_names + 11842, 33}, 2501 }, + { {OperationResultCode_names + 11875, 48}, 2513 }, + { {OperationResultCode_names + 11923, 52}, 2511 }, + { {OperationResultCode_names + 11975, 38}, 2515 }, + { {OperationResultCode_names + 12013, 55}, 2512 }, + { {OperationResultCode_names + 12068, 45}, 2506 }, + { {OperationResultCode_names + 12113, 46}, 2507 }, + { {OperationResultCode_names + 12159, 56}, 2502 }, + { {OperationResultCode_names + 12215, 47}, 2509 }, + { {OperationResultCode_names + 12262, 43}, 2508 }, + { {OperationResultCode_names + 12305, 31}, 2516 }, + { {OperationResultCode_names + 12336, 29}, 4568 }, + { {OperationResultCode_names + 12365, 38}, 4611 }, + { {OperationResultCode_names + 12403, 45}, 4612 }, + { {OperationResultCode_names + 12448, 60}, 4609 }, + { {OperationResultCode_names + 12508, 45}, 4500 }, + { {OperationResultCode_names + 12553, 37}, 4571 }, + { {OperationResultCode_names + 12590, 44}, 4504 }, + { {OperationResultCode_names + 12634, 42}, 4572 }, + { {OperationResultCode_names + 12676, 49}, 4515 }, + { {OperationResultCode_names + 12725, 29}, 4518 }, + { {OperationResultCode_names + 12754, 30}, 4579 }, + { {OperationResultCode_names + 12784, 38}, 4536 }, + { {OperationResultCode_names + 12822, 43}, 4570 }, + { {OperationResultCode_names + 12865, 36}, 4578 }, + { {OperationResultCode_names + 12901, 48}, 4501 }, + { {OperationResultCode_names + 12949, 44}, 4585 }, + { {OperationResultCode_names + 12993, 35}, 4592 }, + { {OperationResultCode_names + 13028, 43}, 4506 }, + { {OperationResultCode_names + 13071, 35}, 4530 }, + { {OperationResultCode_names + 13106, 23}, 4520 }, + { {OperationResultCode_names + 13129, 37}, 4538 }, + { {OperationResultCode_names + 13166, 41}, 4563 }, + { {OperationResultCode_names + 13207, 37}, 4602 }, + { {OperationResultCode_names + 13244, 31}, 4610 }, + { {OperationResultCode_names + 13275, 38}, 4606 }, + { {OperationResultCode_names + 13313, 37}, 4591 }, + { {OperationResultCode_names + 13350, 25}, 4567 }, + { {OperationResultCode_names + 13375, 27}, 4605 }, + { {OperationResultCode_names + 13402, 32}, 4503 }, + { {OperationResultCode_names + 13434, 35}, 4514 }, + { {OperationResultCode_names + 13469, 48}, 4588 }, + { {OperationResultCode_names + 13517, 45}, 4552 }, + { {OperationResultCode_names + 13562, 40}, 4532 }, + { {OperationResultCode_names + 13602, 40}, 4535 }, + { {OperationResultCode_names + 13642, 48}, 4547 }, + { {OperationResultCode_names + 13690, 60}, 4556 }, + { {OperationResultCode_names + 13750, 56}, 4558 }, + { {OperationResultCode_names + 13806, 60}, 4557 }, + { {OperationResultCode_names + 13866, 56}, 4553 }, + { {OperationResultCode_names + 13922, 52}, 4555 }, + { {OperationResultCode_names + 13974, 56}, 4554 }, + { {OperationResultCode_names + 14030, 43}, 4559 }, + { {OperationResultCode_names + 14073, 43}, 4560 }, + { {OperationResultCode_names + 14116, 37}, 4561 }, + { {OperationResultCode_names + 14153, 41}, 4562 }, + { {OperationResultCode_names + 14194, 49}, 4586 }, + { {OperationResultCode_names + 14243, 46}, 4505 }, + { {OperationResultCode_names + 14289, 26}, 4519 }, + { {OperationResultCode_names + 14315, 40}, 4537 }, + { {OperationResultCode_names + 14355, 29}, 4566 }, + { {OperationResultCode_names + 14384, 44}, 4507 }, + { {OperationResultCode_names + 14428, 36}, 4531 }, + { {OperationResultCode_names + 14464, 24}, 4525 }, + { {OperationResultCode_names + 14488, 38}, 4539 }, + { {OperationResultCode_names + 14526, 41}, 4593 }, + { {OperationResultCode_names + 14567, 28}, 4594 }, + { {OperationResultCode_names + 14595, 42}, 4564 }, + { {OperationResultCode_names + 14637, 30}, 4569 }, + { {OperationResultCode_names + 14667, 31}, 4607 }, + { {OperationResultCode_names + 14698, 27}, 4587 }, + { {OperationResultCode_names + 14725, 37}, 4573 }, + { {OperationResultCode_names + 14762, 44}, 4508 }, + { {OperationResultCode_names + 14806, 30}, 4577 }, + { {OperationResultCode_names + 14836, 24}, 4522 }, + { {OperationResultCode_names + 14860, 35}, 4601 }, + { {OperationResultCode_names + 14895, 56}, 4608 }, + { {OperationResultCode_names + 14951, 29}, 4603 }, + { {OperationResultCode_names + 14980, 28}, 4604 }, + { {OperationResultCode_names + 15008, 35}, 4590 }, + { {OperationResultCode_names + 15043, 37}, 4576 }, + { {OperationResultCode_names + 15080, 44}, 4513 }, + { {OperationResultCode_names + 15124, 30}, 4582 }, + { {OperationResultCode_names + 15154, 24}, 4521 }, + { {OperationResultCode_names + 15178, 30}, 4583 }, + { {OperationResultCode_names + 15208, 35}, 4502 }, + { {OperationResultCode_names + 15243, 48}, 4512 }, + { {OperationResultCode_names + 15291, 34}, 4584 }, + { {OperationResultCode_names + 15325, 38}, 4589 }, + { {OperationResultCode_names + 15363, 28}, 4524 }, + { {OperationResultCode_names + 15391, 42}, 4540 }, + { {OperationResultCode_names + 15433, 37}, 4599 }, + { {OperationResultCode_names + 15470, 44}, 4575 }, + { {OperationResultCode_names + 15514, 51}, 4509 }, + { {OperationResultCode_names + 15565, 37}, 4581 }, + { {OperationResultCode_names + 15602, 31}, 4523 }, + { {OperationResultCode_names + 15633, 45}, 4541 }, + { {OperationResultCode_names + 15678, 42}, 4600 }, + { {OperationResultCode_names + 15720, 52}, 4511 }, + { {OperationResultCode_names + 15772, 39}, 4516 }, + { {OperationResultCode_names + 15811, 41}, 4533 }, + { {OperationResultCode_names + 15852, 32}, 4527 }, + { {OperationResultCode_names + 15884, 32}, 4529 }, + { {OperationResultCode_names + 15916, 28}, 4528 }, + { {OperationResultCode_names + 15944, 46}, 4546 }, + { {OperationResultCode_names + 15990, 48}, 4549 }, + { {OperationResultCode_names + 16038, 48}, 4551 }, + { {OperationResultCode_names + 16086, 51}, 4596 }, + { {OperationResultCode_names + 16137, 43}, 4595 }, + { {OperationResultCode_names + 16180, 54}, 4545 }, + { {OperationResultCode_names + 16234, 54}, 4542 }, + { {OperationResultCode_names + 16288, 53}, 4510 }, + { {OperationResultCode_names + 16341, 40}, 4517 }, + { {OperationResultCode_names + 16381, 52}, 4544 }, + { {OperationResultCode_names + 16433, 44}, 4534 }, + { {OperationResultCode_names + 16477, 33}, 4526 }, + { {OperationResultCode_names + 16510, 49}, 4548 }, + { {OperationResultCode_names + 16559, 49}, 4550 }, + { {OperationResultCode_names + 16608, 52}, 4598 }, + { {OperationResultCode_names + 16660, 44}, 4597 }, + { {OperationResultCode_names + 16704, 55}, 4543 }, + { {OperationResultCode_names + 16759, 42}, 4574 }, + { {OperationResultCode_names + 16801, 35}, 4580 }, + { {OperationResultCode_names + 16836, 32}, 4565 }, }; static const int OperationResultCode_entries_by_number[] = { - 198, // 0 -> DETAIL_UNKNOWN - 197, // 1 -> DETAIL_SUCCESS + 202, // 0 -> DETAIL_UNKNOWN + 201, // 1 -> DETAIL_SUCCESS 28, // 500 -> CLIENT_CANCELLATION_REMOTE_IN_CANCELED_STATE 24, // 501 -> CLIENT_CANCELLATION_LOCAL_CANCEL_PAYLOAD 26, // 502 -> CLIENT_CANCELLATION_REMOTE_CANCEL_PAYLOAD @@ -2882,59 +2949,59 @@ static const int OperationResultCode_entries_by_number[] = { 27, // 523 -> CLIENT_CANCELLATION_REMOTE_DISCONNECT 9, // 524 -> CLIENT_CANCELLATION_AWDL_SERVER_SOCKET_CREATION 11, // 525 -> CLIENT_CANCELLATION_CANCEL_AWDL_OUTGOING_CONNECTION - 199, // 1000 -> DEVICE_STATE_ERROR_UNFINISHED_UPGRADE_ATTEMPTS - 200, // 1001 -> DEVICE_STATE_ERROR_USER_HOTSPOT_ENABLED - 201, // 1002 -> DEVICE_STATE_LOCATION_DISABLED - 202, // 1003 -> DEVICE_STATE_RADIO_DISABLING_FAILURE - 203, // 1004 -> DEVICE_STATE_RADIO_ENABLING_FAILURE - 260, // 1500 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_RESOURCE_NOT_AVAILABLE - 227, // 1501 -> MEDIUM_UNAVAILABLE_DIRECT_HOTSPOT_NOT_SUPPORT - 243, // 1502 -> MEDIUM_UNAVAILABLE_SOFT_AP_NOT_SUPPORT - 234, // 1503 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT - 235, // 1504 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT_5G - 223, // 1505 -> MEDIUM_UNAVAILABLE_BLE_NOT_AVAILABLE - 229, // 1506 -> MEDIUM_UNAVAILABLE_L2CAP_NOT_AVAILABLE - 224, // 1507 -> MEDIUM_UNAVAILABLE_BLUETOOTH_NOT_AVAILABLE - 256, // 1508 -> MEDIUM_UNAVAILABLE_WEB_RTC_NOT_AVAILABLE - 259, // 1509 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_NOT_AVAILABLE - 265, // 1510 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NOT_AVAILABLE - 262, // 1511 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_NOT_AVAILABLE - 238, // 1512 -> MEDIUM_UNAVAILABLE_NFC_NOT_AVAILABLE - 232, // 1513 -> MEDIUM_UNAVAILABLE_LAN_NOT_AVAILABLE - 254, // 1514 -> MEDIUM_UNAVAILABLE_USB_NOT_AVAILABLE - 222, // 1515 -> MEDIUM_UNAVAILABLE_BLE_NC_LOGICAL_NOT_AVAILABLE - 226, // 1516 -> MEDIUM_UNAVAILABLE_BT_NC_LOGICAL_NOT_AVAILABLE - 231, // 1517 -> MEDIUM_UNAVAILABLE_LAN_NC_LOGICAL_NOT_AVAILABLE - 237, // 1518 -> MEDIUM_UNAVAILABLE_NFC_NC_LOGICAL_NOT_AVAILABLE - 253, // 1519 -> MEDIUM_UNAVAILABLE_USB_NC_LOGICAL_NOT_AVAILABLE - 255, // 1520 -> MEDIUM_UNAVAILABLE_WEB_RTC_NC_LOGICAL_NOT_AVAILABLE - 258, // 1521 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_NC_LOGICAL_NOT_AVAILABLE - 264, // 1522 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NC_LOGICAL_NOT_AVAILABLE - 261, // 1523 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_NC_LOGICAL_NOT_AVAILABLE - 266, // 1524 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_P2P_RESOURCE_NOT_AVAILABLE - 263, // 1525 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_P2P_RESOURCE_NOT_AVAILABLE - 247, // 1526 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BLE_LOW_QUALITY_MEDIUMS - 249, // 1527 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_L2CAP_LOW_QUALITY_MEDIUMS - 252, // 1528 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_WEB_RTC_LOW_QUALITY_MEDIUMS - 250, // 1529 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_LAN_LOW_QUALITY_MEDIUMS - 248, // 1530 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BT_LOW_QUALITY_MEDIUMS - 251, // 1531 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_USB_LOW_QUALITY_MEDIUMS - 233, // 1532 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_DISRUPTIVE_FALSE - 242, // 1533 -> MEDIUM_UNAVAILABLE_SOFT_AP_DISRUPTIVE_FALSE - 219, // 1534 -> MEDIUM_UNAVAILABLE_ALREADY_HAVE_A_WIFI_DIRECT_GROUP - 220, // 1535 -> MEDIUM_UNAVAILABLE_ALREADY_HOSTING_HOTSPOT_FOR_OTHER_CLIENTS - 241, // 1536 -> MEDIUM_UNAVAILABLE_REJECT_L2CAP_ON_GATT_MULTIPLEX_CONNECTION - 246, // 1537 -> MEDIUM_UNAVAILABLE_UPGRADE_ON_SAME_MEDIUM - 257, // 1538 -> MEDIUM_UNAVAILABLE_WEB_RTC_NO_INTERNET - 244, // 1539 -> MEDIUM_UNAVAILABLE_STA_DISRUPTIVE_FALSE - 245, // 1540 -> MEDIUM_UNAVAILABLE_STA_USER_NOT_ALLOW - 228, // 1541 -> MEDIUM_UNAVAILABLE_DUPLICATE_FAST_ADVERTISING - 239, // 1542 -> MEDIUM_UNAVAILABLE_NSD_NOT_AVAILABLE - 236, // 1543 -> MEDIUM_UNAVAILABLE_MDNS_NOT_AVAILABLE - 230, // 1544 -> MEDIUM_UNAVAILABLE_LAN_BLOCKED - 240, // 1545 -> MEDIUM_UNAVAILABLE_POOR_SIGNAL - 225, // 1546 -> MEDIUM_UNAVAILABLE_BT_MULTIPLEX_DISABLED - 221, // 1547 -> MEDIUM_UNAVAILABLE_AWDL_NOT_AVAILABLE + 203, // 1000 -> DEVICE_STATE_ERROR_UNFINISHED_UPGRADE_ATTEMPTS + 204, // 1001 -> DEVICE_STATE_ERROR_USER_HOTSPOT_ENABLED + 205, // 1002 -> DEVICE_STATE_LOCATION_DISABLED + 206, // 1003 -> DEVICE_STATE_RADIO_DISABLING_FAILURE + 207, // 1004 -> DEVICE_STATE_RADIO_ENABLING_FAILURE + 264, // 1500 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_RESOURCE_NOT_AVAILABLE + 231, // 1501 -> MEDIUM_UNAVAILABLE_DIRECT_HOTSPOT_NOT_SUPPORT + 247, // 1502 -> MEDIUM_UNAVAILABLE_SOFT_AP_NOT_SUPPORT + 238, // 1503 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT + 239, // 1504 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_NOT_SUPPORT_5G + 227, // 1505 -> MEDIUM_UNAVAILABLE_BLE_NOT_AVAILABLE + 233, // 1506 -> MEDIUM_UNAVAILABLE_L2CAP_NOT_AVAILABLE + 228, // 1507 -> MEDIUM_UNAVAILABLE_BLUETOOTH_NOT_AVAILABLE + 260, // 1508 -> MEDIUM_UNAVAILABLE_WEB_RTC_NOT_AVAILABLE + 263, // 1509 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_NOT_AVAILABLE + 269, // 1510 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NOT_AVAILABLE + 266, // 1511 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_NOT_AVAILABLE + 242, // 1512 -> MEDIUM_UNAVAILABLE_NFC_NOT_AVAILABLE + 236, // 1513 -> MEDIUM_UNAVAILABLE_LAN_NOT_AVAILABLE + 258, // 1514 -> MEDIUM_UNAVAILABLE_USB_NOT_AVAILABLE + 226, // 1515 -> MEDIUM_UNAVAILABLE_BLE_NC_LOGICAL_NOT_AVAILABLE + 230, // 1516 -> MEDIUM_UNAVAILABLE_BT_NC_LOGICAL_NOT_AVAILABLE + 235, // 1517 -> MEDIUM_UNAVAILABLE_LAN_NC_LOGICAL_NOT_AVAILABLE + 241, // 1518 -> MEDIUM_UNAVAILABLE_NFC_NC_LOGICAL_NOT_AVAILABLE + 257, // 1519 -> MEDIUM_UNAVAILABLE_USB_NC_LOGICAL_NOT_AVAILABLE + 259, // 1520 -> MEDIUM_UNAVAILABLE_WEB_RTC_NC_LOGICAL_NOT_AVAILABLE + 262, // 1521 -> MEDIUM_UNAVAILABLE_WIFI_AWARE_NC_LOGICAL_NOT_AVAILABLE + 268, // 1522 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_NC_LOGICAL_NOT_AVAILABLE + 265, // 1523 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_NC_LOGICAL_NOT_AVAILABLE + 270, // 1524 -> MEDIUM_UNAVAILABLE_WIFI_HOTSPOT_P2P_RESOURCE_NOT_AVAILABLE + 267, // 1525 -> MEDIUM_UNAVAILABLE_WIFI_DIRECT_P2P_RESOURCE_NOT_AVAILABLE + 251, // 1526 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BLE_LOW_QUALITY_MEDIUMS + 253, // 1527 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_L2CAP_LOW_QUALITY_MEDIUMS + 256, // 1528 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_WEB_RTC_LOW_QUALITY_MEDIUMS + 254, // 1529 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_LAN_LOW_QUALITY_MEDIUMS + 252, // 1530 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_BT_LOW_QUALITY_MEDIUMS + 255, // 1531 -> MEDIUM_UNAVAILABLE_UPGRADE_SKIP_USB_LOW_QUALITY_MEDIUMS + 237, // 1532 -> MEDIUM_UNAVAILABLE_LOCAL_ONLY_HOTSPOT_DISRUPTIVE_FALSE + 246, // 1533 -> MEDIUM_UNAVAILABLE_SOFT_AP_DISRUPTIVE_FALSE + 223, // 1534 -> MEDIUM_UNAVAILABLE_ALREADY_HAVE_A_WIFI_DIRECT_GROUP + 224, // 1535 -> MEDIUM_UNAVAILABLE_ALREADY_HOSTING_HOTSPOT_FOR_OTHER_CLIENTS + 245, // 1536 -> MEDIUM_UNAVAILABLE_REJECT_L2CAP_ON_GATT_MULTIPLEX_CONNECTION + 250, // 1537 -> MEDIUM_UNAVAILABLE_UPGRADE_ON_SAME_MEDIUM + 261, // 1538 -> MEDIUM_UNAVAILABLE_WEB_RTC_NO_INTERNET + 248, // 1539 -> MEDIUM_UNAVAILABLE_STA_DISRUPTIVE_FALSE + 249, // 1540 -> MEDIUM_UNAVAILABLE_STA_USER_NOT_ALLOW + 232, // 1541 -> MEDIUM_UNAVAILABLE_DUPLICATE_FAST_ADVERTISING + 243, // 1542 -> MEDIUM_UNAVAILABLE_NSD_NOT_AVAILABLE + 240, // 1543 -> MEDIUM_UNAVAILABLE_MDNS_NOT_AVAILABLE + 234, // 1544 -> MEDIUM_UNAVAILABLE_LAN_BLOCKED + 244, // 1545 -> MEDIUM_UNAVAILABLE_POOR_SIGNAL + 229, // 1546 -> MEDIUM_UNAVAILABLE_BT_MULTIPLEX_DISABLED + 225, // 1547 -> MEDIUM_UNAVAILABLE_AWDL_NOT_AVAILABLE 60, // 2000 -> CLIENT_WIFI_DIRECT_ALREADY_HOSTING_DIRECT_GROUP_FOR_THIS_CLIENT 61, // 2001 -> CLIENT_WIFI_HOTSPOT_ALREADY_HOSTING_HOTSPOT_FOR_THIS_CLIENT 37, // 2002 -> CLIENT_DUPLICATE_ACCEPTING_BLE_CONNECTION_REQUEST @@ -2974,38 +3041,38 @@ static const int OperationResultCode_entries_by_number[] = { 2, // 2036 -> CLIENT_AWDL_DUPLICATE_ADVERTISING 3, // 2037 -> CLIENT_AWDL_DUPLICATE_DISCOVERING 36, // 2038 -> CLIENT_DUPLICATE_ACCEPTING_AWDL_CONNECTION_REQUEST - 269, // 2500 -> MISCELLEANEOUS_BLUETOOTH_MAC_ADDRESS_NULL - 273, // 2501 -> MISCELLEANEOUS_MOVE_TO_NEW_MEDIUM - 280, // 2502 -> MISCELLEANEOUS_WIFI_HOTSPOT_SOFT_AP_BLOCKED_BY_PROVISION - 267, // 2503 -> MISCELLEANEOUS_BLE_SYSTEM_SERVICE_NULL - 272, // 2504 -> MISCELLEANEOUS_L2CAP_SYSTEM_SERVICE_NULL - 271, // 2505 -> MISCELLEANEOUS_BT_SYSTEM_SERVICE_NULL - 278, // 2506 -> MISCELLEANEOUS_WIFI_AWARE_SYSTEM_SERVICE_NULL - 279, // 2507 -> MISCELLEANEOUS_WIFI_DIRECT_SYSTEM_SERVICE_NULL - 282, // 2508 -> MISCELLEANEOUS_WIFI_LAN_SYSTEM_SERVICE_NULL - 281, // 2509 -> MISCELLEANEOUS_WIFI_HOTSPOT_SYSTEM_SERVICE_NULL - 270, // 2510 -> MISCELLEANEOUS_BT_NOT_ACCEPTING_CONNECTION_FOR_WORK_PROFILE - 275, // 2511 -> MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE - 277, // 2512 -> MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL - 274, // 2513 -> MISCELLEANEOUS_WEB_RTC_FAILED_TO_RECEIVE_MESSAGE - 268, // 2514 -> MISCELLEANEOUS_BLUETOOTH_CHANGE_DEVICE_NAME_FAILURE - 276, // 2515 -> MISCELLEANEOUS_WEB_RTC_ICE_SERVER_NULL - 283, // 2516 -> MISCELLEANEOUS_WORK_SOURCE_NULL - 214, // 3000 -> IO_FILE_OPENING_ERROR - 215, // 3001 -> IO_FILE_READING_ERROR - 216, // 3002 -> IO_FILE_WRITING_ERROR - 217, // 3003 -> IO_FOLDER_CREATION_ERROR - 218, // 3004 -> IO_STREAM_CREATE_PIPE_FAILURE - 204, // 3005 -> IO_ENDPOINT_IO_ERROR_ON_BLE - 205, // 3006 -> IO_ENDPOINT_IO_ERROR_ON_BLE_L2CAP - 206, // 3007 -> IO_ENDPOINT_IO_ERROR_ON_BT - 210, // 3008 -> IO_ENDPOINT_IO_ERROR_ON_WEB_RTC - 207, // 3009 -> IO_ENDPOINT_IO_ERROR_ON_LAN - 212, // 3010 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_DIRECT - 213, // 3011 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_HOTSPOT - 211, // 3012 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_AWARE - 208, // 3013 -> IO_ENDPOINT_IO_ERROR_ON_NFC - 209, // 3014 -> IO_ENDPOINT_IO_ERROR_ON_USB + 273, // 2500 -> MISCELLEANEOUS_BLUETOOTH_MAC_ADDRESS_NULL + 277, // 2501 -> MISCELLEANEOUS_MOVE_TO_NEW_MEDIUM + 284, // 2502 -> MISCELLEANEOUS_WIFI_HOTSPOT_SOFT_AP_BLOCKED_BY_PROVISION + 271, // 2503 -> MISCELLEANEOUS_BLE_SYSTEM_SERVICE_NULL + 276, // 2504 -> MISCELLEANEOUS_L2CAP_SYSTEM_SERVICE_NULL + 275, // 2505 -> MISCELLEANEOUS_BT_SYSTEM_SERVICE_NULL + 282, // 2506 -> MISCELLEANEOUS_WIFI_AWARE_SYSTEM_SERVICE_NULL + 283, // 2507 -> MISCELLEANEOUS_WIFI_DIRECT_SYSTEM_SERVICE_NULL + 286, // 2508 -> MISCELLEANEOUS_WIFI_LAN_SYSTEM_SERVICE_NULL + 285, // 2509 -> MISCELLEANEOUS_WIFI_HOTSPOT_SYSTEM_SERVICE_NULL + 274, // 2510 -> MISCELLEANEOUS_BT_NOT_ACCEPTING_CONNECTION_FOR_WORK_PROFILE + 279, // 2511 -> MISCELLEANEOUS_WEB_RTC_GET_DROIDGUARD_RESULT_FAILURE + 281, // 2512 -> MISCELLEANEOUS_WEB_RTC_TACHYON_SIGNALING_MESSENGER_NULL + 278, // 2513 -> MISCELLEANEOUS_WEB_RTC_FAILED_TO_RECEIVE_MESSAGE + 272, // 2514 -> MISCELLEANEOUS_BLUETOOTH_CHANGE_DEVICE_NAME_FAILURE + 280, // 2515 -> MISCELLEANEOUS_WEB_RTC_ICE_SERVER_NULL + 287, // 2516 -> MISCELLEANEOUS_WORK_SOURCE_NULL + 218, // 3000 -> IO_FILE_OPENING_ERROR + 219, // 3001 -> IO_FILE_READING_ERROR + 220, // 3002 -> IO_FILE_WRITING_ERROR + 221, // 3003 -> IO_FOLDER_CREATION_ERROR + 222, // 3004 -> IO_STREAM_CREATE_PIPE_FAILURE + 208, // 3005 -> IO_ENDPOINT_IO_ERROR_ON_BLE + 209, // 3006 -> IO_ENDPOINT_IO_ERROR_ON_BLE_L2CAP + 210, // 3007 -> IO_ENDPOINT_IO_ERROR_ON_BT + 214, // 3008 -> IO_ENDPOINT_IO_ERROR_ON_WEB_RTC + 211, // 3009 -> IO_ENDPOINT_IO_ERROR_ON_LAN + 216, // 3010 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_DIRECT + 217, // 3011 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_HOTSPOT + 215, // 3012 -> IO_ENDPOINT_IO_ERROR_ON_WIFI_AWARE + 212, // 3013 -> IO_ENDPOINT_IO_ERROR_ON_NFC + 213, // 3014 -> IO_ENDPOINT_IO_ERROR_ON_USB 135, // 3500 -> CONNECTIVITY_WIFI_AWARE_ATTACH_FAILURE 78, // 3501 -> CONNECTIVITY_BLUETOOTH_DEVICE_OBTAIN_FAILURE 71, // 3502 -> CONNECTIVITY_BLE_CLIENT_SOCKET_CREATION_FAILURE @@ -3015,47 +3082,47 @@ static const int OperationResultCode_entries_by_number[] = { 121, // 3506 -> CONNECTIVITY_NFC_CLIENT_SOCKET_CREATION_FAILURE 126, // 3507 -> CONNECTIVITY_WEB_RTC_CLIENT_SOCKET_CREATION_FAILURE 136, // 3508 -> CONNECTIVITY_WIFI_AWARE_CLIENT_SOCKET_CREATION_FAILURE - 155, // 3509 -> CONNECTIVITY_WIFI_HOTSPOT_CLIENT_SOCKET_CREATION_FAILURE - 147, // 3510 -> CONNECTIVITY_WIFI_DIRECT_CLIENT_SOCKET_CREATION_FAILURE + 159, // 3509 -> CONNECTIVITY_WIFI_HOTSPOT_CLIENT_SOCKET_CREATION_FAILURE + 151, // 3510 -> CONNECTIVITY_WIFI_DIRECT_CLIENT_SOCKET_CREATION_FAILURE 124, // 3511 -> CONNECTIVITY_USB_CLIENT_SOCKET_CREATION_FAILURE 127, // 3512 -> CONNECTIVITY_WEB_RTC_CONNECT_TO_TACHYON_FAILURE 72, // 3513 -> CONNECTIVITY_BLE_CREATE_GATT_CONNECTION_FAILURE - 139, // 3514 -> CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_FRAME_FAILURE - 138, // 3515 -> CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_ADDRESS_FAILURE - 149, // 3516 -> CONNECTIVITY_WIFI_DIRECT_INCONSISTENT_HOSTED_WIFI_BAND - 157, // 3517 -> CONNECTIVITY_WIFI_HOTSPOT_INCONSISTENT_HOSTED_WIFI_BAND + 142, // 3514 -> CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_FRAME_FAILURE + 141, // 3515 -> CONNECTIVITY_WIFI_AWARE_GET_REMOTE_IP_ADDRESS_FAILURE + 153, // 3516 -> CONNECTIVITY_WIFI_DIRECT_INCONSISTENT_HOSTED_WIFI_BAND + 161, // 3517 -> CONNECTIVITY_WIFI_HOTSPOT_INCONSISTENT_HOSTED_WIFI_BAND 79, // 3518 -> CONNECTIVITY_BLUETOOTH_INVALID_CREDENTIAL - 166, // 3519 -> CONNECTIVITY_WIFI_LAN_INVALID_CREDENTIAL - 150, // 3520 -> CONNECTIVITY_WIFI_DIRECT_INVALID_CREDENTIAL - 158, // 3521 -> CONNECTIVITY_WIFI_HOTSPOT_INVALID_CREDENTIAL - 140, // 3522 -> CONNECTIVITY_WIFI_AWARE_INVALID_CREDENTIAL + 170, // 3519 -> CONNECTIVITY_WIFI_LAN_INVALID_CREDENTIAL + 154, // 3520 -> CONNECTIVITY_WIFI_DIRECT_INVALID_CREDENTIAL + 162, // 3521 -> CONNECTIVITY_WIFI_HOTSPOT_INVALID_CREDENTIAL + 143, // 3522 -> CONNECTIVITY_WIFI_AWARE_INVALID_CREDENTIAL 128, // 3523 -> CONNECTIVITY_WEB_RTC_INVALID_CREDENTIAL - 167, // 3524 -> CONNECTIVITY_WIFI_LAN_IP_ADDRESS_ERROR + 171, // 3524 -> CONNECTIVITY_WIFI_LAN_IP_ADDRESS_ERROR 108, // 3525 -> CONNECTIVITY_L2CAP_CLIENT_OBTAIN_FAIURE 111, // 3526 -> CONNECTIVITY_L2CAP_DATA_CONNECTION_FAILURE - 141, // 3527 -> CONNECTIVITY_WIFI_AWARE_L2MESSAGE_NETWORK_AVAILABLE_FRAME_NULL - 142, // 3528 -> CONNECTIVITY_WIFI_AWARE_L2MESSAGE_SEND_HOST_NETWORK_FRAME_FAILURE + 145, // 3527 -> CONNECTIVITY_WIFI_AWARE_L2MESSAGE_NETWORK_AVAILABLE_FRAME_NULL + 146, // 3528 -> CONNECTIVITY_WIFI_AWARE_L2MESSAGE_SEND_HOST_NETWORK_FRAME_FAILURE 118, // 3529 -> CONNECTIVITY_LAN_UNREACHABLE - 160, // 3530 -> CONNECTIVITY_WIFI_HOTSPOT_LOHS_CREATION_FAILURE + 164, // 3530 -> CONNECTIVITY_WIFI_HOTSPOT_LOHS_CREATION_FAILURE 115, // 3531 -> CONNECTIVITY_LAN_GET_NETWORK_INTERFACES_FAILURE - 148, // 3532 -> CONNECTIVITY_WIFI_DIRECT_GET_NETWORK_INTERFACES_FAILURE - 156, // 3533 -> CONNECTIVITY_WIFI_HOTSPOT_GET_NETWORK_INTERFACES_FAILURE - 161, // 3534 -> CONNECTIVITY_WIFI_HOTSPOT_P2P_CHANNEL_INITIALIZE_FAILURE - 151, // 3535 -> CONNECTIVITY_WIFI_DIRECT_P2P_CHANNEL_INITIALIZE_FAILURE - 162, // 3536 -> CONNECTIVITY_WIFI_HOTSPOT_P2P_GROUP_CREATION_FAILURE - 153, // 3537 -> CONNECTIVITY_WIFI_DIRECT_P2P_GROUP_CREATION_FAILURE + 152, // 3532 -> CONNECTIVITY_WIFI_DIRECT_GET_NETWORK_INTERFACES_FAILURE + 160, // 3533 -> CONNECTIVITY_WIFI_HOTSPOT_GET_NETWORK_INTERFACES_FAILURE + 165, // 3534 -> CONNECTIVITY_WIFI_HOTSPOT_P2P_CHANNEL_INITIALIZE_FAILURE + 155, // 3535 -> CONNECTIVITY_WIFI_DIRECT_P2P_CHANNEL_INITIALIZE_FAILURE + 166, // 3536 -> CONNECTIVITY_WIFI_HOTSPOT_P2P_GROUP_CREATION_FAILURE + 157, // 3537 -> CONNECTIVITY_WIFI_DIRECT_P2P_GROUP_CREATION_FAILURE 103, // 3538 -> CONNECTIVITY_GATT_SERVER_OPEN_FAILURE 74, // 3539 -> CONNECTIVITY_BLE_SERVER_SOCKET_CREATION_FAILURE 112, // 3540 -> CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_FAILURE 86, // 3541 -> CONNECTIVITY_BT_SERVER_SOCKET_CREATION_FAILURE 117, // 3542 -> CONNECTIVITY_LAN_SERVER_SOCKET_CREATION_FAILURE 129, // 3543 -> CONNECTIVITY_WEB_RTC_SERVER_SOCKET_CREATION_FAILURE - 143, // 3544 -> CONNECTIVITY_WIFI_AWARE_SERVER_SOCKET_CREATION_FAILURE - 163, // 3545 -> CONNECTIVITY_WIFI_HOTSPOT_SERVER_SOCKET_CREATION_FAILURE - 154, // 3546 -> CONNECTIVITY_WIFI_DIRECT_SERVER_SOCKET_CREATION_FAILURE + 147, // 3544 -> CONNECTIVITY_WIFI_AWARE_SERVER_SOCKET_CREATION_FAILURE + 167, // 3545 -> CONNECTIVITY_WIFI_HOTSPOT_SERVER_SOCKET_CREATION_FAILURE + 158, // 3546 -> CONNECTIVITY_WIFI_DIRECT_SERVER_SOCKET_CREATION_FAILURE 122, // 3547 -> CONNECTIVITY_NFC_SERVER_SOCKET_CREATION_FAILURE - 164, // 3548 -> CONNECTIVITY_WIFI_HOTSPOT_SOFT_AP_CREATION_FAILURE - 146, // 3549 -> CONNECTIVITY_WIFI_AWARE_UPDATE_PUBLISH_FAILURE + 168, // 3548 -> CONNECTIVITY_WIFI_HOTSPOT_SOFT_AP_CREATION_FAILURE + 150, // 3549 -> CONNECTIVITY_WIFI_AWARE_UPDATE_PUBLISH_FAILURE 106, // 3550 -> CONNECTIVITY_GENERIC_WRITING_CHANNEL_IO_ERROR 105, // 3551 -> CONNECTIVITY_GENERIC_WRITE_CLIENT_INTRODUCTION_ACK_IO_ERROR 137, // 3552 -> CONNECTIVITY_WIFI_AWARE_DISCOVERED_PEER_NULL @@ -3081,27 +3148,27 @@ static const int OperationResultCode_entries_by_number[] = { 84, // 3572 -> CONNECTIVITY_BT_CONNECTION_INTERRUPTED_EXCEPTION 83, // 3573 -> CONNECTIVITY_BT_CONNECTION_EXECUTION_EXCEPTION 85, // 3574 -> CONNECTIVITY_BT_CONNECTION_TIMEOUT_EXCEPTION - 152, // 3575 -> CONNECTIVITY_WIFI_DIRECT_P2P_CONNECTION_FAILURE + 156, // 3575 -> CONNECTIVITY_WIFI_DIRECT_P2P_CONNECTION_FAILURE 133, // 3576 -> CONNECTIVITY_WFD_CONNECTION_INTERRUPTED_EXCEPTION 131, // 3577 -> CONNECTIVITY_WFD_CONNECTION_EXECUTION_EXCEPTION 134, // 3578 -> CONNECTIVITY_WFD_CONNECTION_TIMEOUT_EXCEPTION 132, // 3579 -> CONNECTIVITY_WFD_CONNECTION_HOSTED_ADDRESS_NULL - 165, // 3580 -> CONNECTIVITY_WIFI_HOTSPOT_SPECIFIER_FAILURE - 159, // 3581 -> CONNECTIVITY_WIFI_HOTSPOT_LEGACY_STA_CONNECTION_FAILURE - 169, // 3582 -> CONNECTIVITY_WIFI_LAN_SOCKET_CONNECT_TIMEOUT - 168, // 3583 -> CONNECTIVITY_WIFI_LAN_SOCKET_CONNECT_IO_EXCEPTION + 169, // 3580 -> CONNECTIVITY_WIFI_HOTSPOT_SPECIFIER_FAILURE + 163, // 3581 -> CONNECTIVITY_WIFI_HOTSPOT_LEGACY_STA_CONNECTION_FAILURE + 173, // 3582 -> CONNECTIVITY_WIFI_LAN_SOCKET_CONNECT_TIMEOUT + 172, // 3583 -> CONNECTIVITY_WIFI_LAN_SOCKET_CONNECT_IO_EXCEPTION 76, // 3584 -> CONNECTIVITY_BLE_START_GATT_SERVER_FAILURE 70, // 3585 -> CONNECTIVITY_BLE_ADD_GATT_ADVERTISEMENT_FAILURE 75, // 3586 -> CONNECTIVITY_BLE_START_ADVERTISING_FAILURE 81, // 3587 -> CONNECTIVITY_BLUETOOTH_START_ADVERTISING_FAILURE - 170, // 3588 -> CONNECTIVITY_WIFI_LAN_START_ADVERTISING_FAILURE - 144, // 3589 -> CONNECTIVITY_WIFI_AWARE_START_ADVERTISING_FAILURE + 174, // 3588 -> CONNECTIVITY_WIFI_LAN_START_ADVERTISING_FAILURE + 148, // 3589 -> CONNECTIVITY_WIFI_AWARE_START_ADVERTISING_FAILURE 80, // 3590 -> CONNECTIVITY_BLUETOOTH_SCAN_FAILURE 73, // 3591 -> CONNECTIVITY_BLE_SCAN_FAILURE 119, // 3592 -> CONNECTIVITY_MDNS_SCAN_FAILURE 123, // 3593 -> CONNECTIVITY_NFC_START_DISCOVERY_FAILURE - 171, // 3594 -> CONNECTIVITY_WIFI_LAN_START_DISCOVERY_FAILURE - 145, // 3595 -> CONNECTIVITY_WIFI_AWARE_START_DISCOVERY_FAILURE + 175, // 3594 -> CONNECTIVITY_WIFI_LAN_START_DISCOVERY_FAILURE + 149, // 3595 -> CONNECTIVITY_WIFI_AWARE_START_DISCOVERY_FAILURE 125, // 3596 -> CONNECTIVITY_UWB_START_DISCOVERY_FAILURE 116, // 3597 -> CONNECTIVITY_LAN_MDNS_REGISTER_FAILURE 77, // 3598 -> CONNECTIVITY_BLUETOOTH_CHANGE_SCAN_MODE_FAILURE @@ -3113,144 +3180,148 @@ static const int OperationResultCode_entries_by_number[] = { 67, // 3604 -> CONNECTIVITY_AWDL_INVALID_CREDENTIAL 66, // 3605 -> CONNECTIVITY_AWDL_CLIENT_SOCKET_CREATION_FAILURE 90, // 3606 -> CONNECTIVITY_CHANNEL_IO_ERROR_ON_AWDL - 288, // 4500 -> NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR - 298, // 4501 -> NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT - 358, // 4502 -> NEARBY_WEB_RTC_CONNECTION_FLOW_NULL - 312, // 4503 -> NEARBY_GENERIC_CONNECTION_CLOSED - 290, // 4504 -> NEARBY_BLE_ENDPOINT_CHANNEL_CREATION_FAILURE - 330, // 4505 -> NEARBY_L2CAP_ENDPOINT_CHANNEL_CREATION_FAILURE - 301, // 4506 -> NEARBY_BT_ENDPOINT_CHANNEL_CREATION_FAILURE - 334, // 4507 -> NEARBY_LAN_ENDPOINT_CHANNEL_CREATION_FAILURE - 345, // 4508 -> NEARBY_NFC_ENDPOINT_CHANNEL_CREATION_FAILURE - 366, // 4509 -> NEARBY_WIFI_AWARE_ENDPOINT_CHANNEL_CREATION_FAILURE - 384, // 4510 -> NEARBY_WIFI_HOTSPOT_ENDPOINT_CHANNEL_CREATION_FAILURE - 371, // 4511 -> NEARBY_WIFI_DIRECT_ENDPOINT_CHANNEL_CREATION_FAILURE - 359, // 4512 -> NEARBY_WEB_RTC_ENDPOINT_CHANNEL_CREATION_FAILURE - 354, // 4513 -> NEARBY_USB_ENDPOINT_CHANNEL_CREATION_FAILURE - 313, // 4514 -> NEARBY_GENERIC_ENDPOINT_UNENCRYPTED - 292, // 4515 -> NEARBY_BLE_GATT_ADVERTISEMENT_NULL_FOR_CONNECTION - 372, // 4516 -> NEARBY_WIFI_DIRECT_HOST_ON_SRD_CHANNELS - 385, // 4517 -> NEARBY_WIFI_HOTSPOT_HOST_ON_SRD_CHANNELS - 293, // 4518 -> NEARBY_BLE_GATT_NULL_CALLBACK - 331, // 4519 -> NEARBY_L2CAP_NULL_CALLBACK - 303, // 4520 -> NEARBY_BT_NULL_CALLBACK - 356, // 4521 -> NEARBY_USB_NULL_CALLBACK - 347, // 4522 -> NEARBY_NFC_NULL_CALLBACK - 368, // 4523 -> NEARBY_WIFI_AWARE_NULL_CALLBACK - 362, // 4524 -> NEARBY_WEB_RTC_NULL_CALLBACK - 336, // 4525 -> NEARBY_LAN_NULL_CALLBACK - 388, // 4526 -> NEARBY_WIFI_HOTSPOT_NULL_CALLBACK - 374, // 4527 -> NEARBY_WIFI_DIRECT_NULL_CALLBACK - 376, // 4528 -> NEARBY_WIFI_DIRECT_NULL_SSID - 375, // 4529 -> NEARBY_WIFI_DIRECT_NULL_PASSWORD - 302, // 4530 -> NEARBY_BT_MULTIPLEX_SOCKET_DISABLED - 335, // 4531 -> NEARBY_LAN_MULTIPLEX_SOCKET_DISABLED - 316, // 4532 -> NEARBY_GENERIC_NEW_ENDPOINT_CHANNEL_NULL - 373, // 4533 -> NEARBY_WIFI_DIRECT_NO_GROUP_FOR_LISTENING - 387, // 4534 -> NEARBY_WIFI_HOTSPOT_NO_HOTSPOT_FOR_LISTENING - 317, // 4535 -> NEARBY_GENERIC_OLD_ENDPOINT_CHANNEL_NULL - 295, // 4536 -> NEARBY_BLE_OPERATION_REGISTERED_FAILED - 332, // 4537 -> NEARBY_L2CAP_OPERATION_REGISTERED_FAILED - 304, // 4538 -> NEARBY_BT_OPERATION_REGISTERED_FAILED - 337, // 4539 -> NEARBY_LAN_OPERATION_REGISTERED_FAILED - 363, // 4540 -> NEARBY_WEB_RTC_OPERATION_REGISTERED_FAILED - 369, // 4541 -> NEARBY_WIFI_AWARE_OPERATION_REGISTERED_FAILED - 383, // 4542 -> NEARBY_WIFI_HOTSPOT_DIRECT_OPERATION_REGISTERED_FAILED - 393, // 4543 -> NEARBY_WIFI_HOTSPOT_SOFT_AP_OPERATION_REGISTERED_FAILED - 386, // 4544 -> NEARBY_WIFI_HOTSPOT_LOHS_OPERATION_REGISTERED_FAILED - 382, // 4545 -> NEARBY_WIFI_HOTSPOT_CLIENT_OPERATION_REGISTERED_FAILED - 377, // 4546 -> NEARBY_WIFI_DIRECT_OPERATION_REGISTERED_FAILED - 318, // 4547 -> NEARBY_GENERIC_OUTGOING_PAYLOAD_CREATION_FAILURE - 389, // 4548 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_2G_BUT_AP_5G - 378, // 4549 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_2G_BUT_AP_5G - 390, // 4550 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_5G_BUT_AP_2G - 379, // 4551 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_5G_BUT_AP_2G - 315, // 4552 -> NEARBY_GENERIC_INCOMING_PAYLOAD_NOT_DATA_TYPE - 322, // 4553 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_EVENT_TYPE_ERROR - 324, // 4554 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FRAME_TYPE_ERROR - 323, // 4555 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FORMAT_ERROR - 319, // 4556 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_EVENT_TYPE_ERROR - 321, // 4557 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FRAME_TYPE_ERROR - 320, // 4558 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FORMAT_ERROR - 325, // 4559 -> NEARBY_GENERIC_REMOTE_ENDPOINT_STATUS_ERROR - 326, // 4560 -> NEARBY_GENERIC_REMOTE_REPORT_PAYLOADS_ERROR - 327, // 4561 -> NEARBY_GENERIC_REMOTE_UPGRADE_FAILURE - 328, // 4562 -> NEARBY_GENERIC_SEND_PAYLOAD_EXECUTOR_NULL - 305, // 4563 -> NEARBY_BT_VIRTUAL_SOCKET_CREATION_FAILURE - 340, // 4564 -> NEARBY_LAN_VIRTUAL_SOCKET_CREATION_FAILURE - 396, // 4565 -> NEARBY_WIFI_LAN_IP_ADDRESS_ERROR - 333, // 4566 -> NEARBY_L2CAP_PSM_NOT_POSITIVE - 310, // 4567 -> NEARBY_ENCRYPTION_FAILURE - 284, // 4568 -> NEARBY_AUTHENTICATION_FAILURE - 341, // 4569 -> NEARBY_LAN_VIRTUAL_SOCKET_NULL - 296, // 4570 -> NEARBY_BLUETOOTH_ADVERTISE_TO_BYTES_FAILURE - 289, // 4571 -> NEARBY_BLE_ADVERTISE_TO_BYTES_FAILURE - 291, // 4572 -> NEARBY_BLE_FAST_ADVERTISE_TO_BYTES_FAILURE - 344, // 4573 -> NEARBY_NFC_ADVERTISE_TO_BYTES_FAILURE - 394, // 4574 -> NEARBY_WIFI_LAN_ADVERTISE_TO_BYTES_FAILURE - 365, // 4575 -> NEARBY_WIFI_AWARE_ADVERTISE_TO_BYTES_FAILURE - 353, // 4576 -> NEARBY_USB_ADVERTISE_TO_BYTES_FAILURE - 346, // 4577 -> NEARBY_NFC_INVALID_PCP_OPTIONS - 297, // 4578 -> NEARBY_BLUETOOTH_INVALID_PCP_OPTIONS - 294, // 4579 -> NEARBY_BLE_INVALID_PCP_OPTIONS - 395, // 4580 -> NEARBY_WIFI_LAN_INVALID_PCP_OPTIONS - 367, // 4581 -> NEARBY_WIFI_AWARE_INVALID_PCP_OPTIONS - 355, // 4582 -> NEARBY_USB_INVALID_PCP_OPTIONS - 357, // 4583 -> NEARBY_UWB_INVALID_PCP_OPTIONS - 360, // 4584 -> NEARBY_WEB_RTC_INVALID_PCP_OPTIONS - 299, // 4585 -> NEARBY_BLUETOOTH_NO_CLIENT_REGISTER_FOR_SCAN - 329, // 4586 -> NEARBY_INSTANT_CONNECTION_WRONG_CONNECTIVITY_INFO - 343, // 4587 -> NEARBY_NEED_METHOD_OVERRIDE - 314, // 4588 -> NEARBY_GENERIC_INCOMING_PAYLOAD_CREATION_FAILURE - 361, // 4589 -> NEARBY_WEB_RTC_NO_LISTENING_PEER_FOUND - 352, // 4590 -> NEARBY_UPGRADE_PATH_ON_WRONG_MEDIUM - 309, // 4591 -> NEARBY_CONNECT_TO_ALL_MEDIUMS_FAILURE - 300, // 4592 -> NEARBY_BLUETOOTH_RECONNECT_MAC_NULL - 338, // 4593 -> NEARBY_LAN_RECONNECT_CONNECTION_INFO_NULL - 339, // 4594 -> NEARBY_LAN_RECONNECT_IP_NULL - 381, // 4595 -> NEARBY_WIFI_DIRECT_RECONNECT_META_DATA_NULL - 380, // 4596 -> NEARBY_WIFI_DIRECT_RECONNECT_CONNECT_META_DATA_NULL - 392, // 4597 -> NEARBY_WIFI_HOTSPOT_RECONNECT_META_DATA_NULL - 391, // 4598 -> NEARBY_WIFI_HOTSPOT_RECONNECT_CONNECT_META_DATA_NULL - 364, // 4599 -> NEARBY_WEB_RTC_RECONNECT_PEER_ID_NULL - 370, // 4600 -> NEARBY_WIFI_AWARE_RECONNECT_META_DATA_NULL - 348, // 4601 -> NEARBY_NOT_ADVERTISING_OR_LISTENING - 306, // 4602 -> NEARBY_CAN_NOT_OBTAIN_DEVICE_PROVIDER - 350, // 4603 -> NEARBY_SETUP_STRATEGY_FAILURE - 351, // 4604 -> NEARBY_TX_ADVERTISEMENT_NULL - 311, // 4605 -> NEARBY_ENDPOINT_ID_MISMATCH - 308, // 4606 -> NEARBY_CONNECTIVITY_INFO_NULL_OR_WRONG - 342, // 4607 -> NEARBY_LOCAL_CLIENT_STATE_WRONG - 349, // 4608 -> NEARBY_REMOTE_EXCEPTION_WHEN_PROCESSING_RECEIVED_PAYLOAD - 287, // 4609 -> NEARBY_BAD_FILE_DESCRIPTION_WHEN_PROCESSING_RECEIVED_PAYLOAD - 307, // 4610 -> NEARBY_CONNECTION_LISTENER_NULL - 285, // 4611 -> NEARBY_AWDL_ADVERTISE_TO_BYTES_FAILURE - 286, // 4612 -> NEARBY_AWDL_ENDPOINT_CHANNEL_CREATION_FAILURE - 173, // 5000 -> DCT_ERROR_BLE_DISABLED - 172, // 5001 -> DCT_ERROR_BLE_ADV_FAILED - 174, // 5002 -> DCT_ERROR_BLE_SCAN_FAILED - 183, // 5003 -> DCT_ERROR_L2CAP_SERVER_FAILED - 182, // 5004 -> DCT_ERROR_L2CAP_CLIENT_FAILED - 184, // 5005 -> DCT_ERROR_MDNS_DISCOVERY_TIMEOUT - 185, // 5006 -> DCT_ERROR_MDNS_REGISTER_SERVICE - 180, // 5007 -> DCT_ERROR_INITIAL_TLS_SPAKE - 189, // 5008 -> DCT_ERROR_SUBSEQUENT_TLS_SPAKE - 186, // 5009 -> DCT_ERROR_REQUEST_FAILED - 187, // 5010 -> DCT_ERROR_RESPONSE_FAILED - 176, // 5011 -> DCT_ERROR_CONTROL_MESSAGE_EXCHANGE - 175, // 5012 -> DCT_ERROR_CAPABILITY_MISMATCH - 178, // 5013 -> DCT_ERROR_HIGH_SPEED_MEDIUM_UNAVAILABLE - 194, // 5014 -> DCT_ERROR_WIFI_DISABLED - 195, // 5015 -> DCT_ERROR_WIFI_DISCONNECTED - 193, // 5016 -> DCT_ERROR_WIFI_CREDENTIAL_TRANSFER - 196, // 5017 -> DCT_ERROR_WIFI_INTERNET_CONNECTION - 191, // 5018 -> DCT_ERROR_UPGRADE_HIGH_SPEED_MEDIUM_FAILED - 181, // 5019 -> DCT_ERROR_KEEPALIVE_TIMEOUT - 177, // 5020 -> DCT_ERROR_ESTABLISHED_CONNECTION_LOST - 192, // 5021 -> DCT_ERROR_USER_CANCELLED - 188, // 5022 -> DCT_ERROR_SERVICE_CANCELLED - 190, // 5023 -> DCT_ERROR_UNVERIFIED_INTEGRITY - 179, // 5024 -> DCT_ERROR_HTTP_SERVER_CLOSED + 140, // 3607 -> CONNECTIVITY_WIFI_AWARE_DO_UNAVAILABLE + 138, // 3608 -> CONNECTIVITY_WIFI_AWARE_DISCOVER_PEER_NULL_SCREEN_OFF + 139, // 3609 -> CONNECTIVITY_WIFI_AWARE_DISCOVER_PEER_NULL_TIMEOUT + 144, // 3610 -> CONNECTIVITY_WIFI_AWARE_JOIN_NETWORK_FAILED + 292, // 4500 -> NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR + 302, // 4501 -> NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT + 362, // 4502 -> NEARBY_WEB_RTC_CONNECTION_FLOW_NULL + 316, // 4503 -> NEARBY_GENERIC_CONNECTION_CLOSED + 294, // 4504 -> NEARBY_BLE_ENDPOINT_CHANNEL_CREATION_FAILURE + 334, // 4505 -> NEARBY_L2CAP_ENDPOINT_CHANNEL_CREATION_FAILURE + 305, // 4506 -> NEARBY_BT_ENDPOINT_CHANNEL_CREATION_FAILURE + 338, // 4507 -> NEARBY_LAN_ENDPOINT_CHANNEL_CREATION_FAILURE + 349, // 4508 -> NEARBY_NFC_ENDPOINT_CHANNEL_CREATION_FAILURE + 370, // 4509 -> NEARBY_WIFI_AWARE_ENDPOINT_CHANNEL_CREATION_FAILURE + 388, // 4510 -> NEARBY_WIFI_HOTSPOT_ENDPOINT_CHANNEL_CREATION_FAILURE + 375, // 4511 -> NEARBY_WIFI_DIRECT_ENDPOINT_CHANNEL_CREATION_FAILURE + 363, // 4512 -> NEARBY_WEB_RTC_ENDPOINT_CHANNEL_CREATION_FAILURE + 358, // 4513 -> NEARBY_USB_ENDPOINT_CHANNEL_CREATION_FAILURE + 317, // 4514 -> NEARBY_GENERIC_ENDPOINT_UNENCRYPTED + 296, // 4515 -> NEARBY_BLE_GATT_ADVERTISEMENT_NULL_FOR_CONNECTION + 376, // 4516 -> NEARBY_WIFI_DIRECT_HOST_ON_SRD_CHANNELS + 389, // 4517 -> NEARBY_WIFI_HOTSPOT_HOST_ON_SRD_CHANNELS + 297, // 4518 -> NEARBY_BLE_GATT_NULL_CALLBACK + 335, // 4519 -> NEARBY_L2CAP_NULL_CALLBACK + 307, // 4520 -> NEARBY_BT_NULL_CALLBACK + 360, // 4521 -> NEARBY_USB_NULL_CALLBACK + 351, // 4522 -> NEARBY_NFC_NULL_CALLBACK + 372, // 4523 -> NEARBY_WIFI_AWARE_NULL_CALLBACK + 366, // 4524 -> NEARBY_WEB_RTC_NULL_CALLBACK + 340, // 4525 -> NEARBY_LAN_NULL_CALLBACK + 392, // 4526 -> NEARBY_WIFI_HOTSPOT_NULL_CALLBACK + 378, // 4527 -> NEARBY_WIFI_DIRECT_NULL_CALLBACK + 380, // 4528 -> NEARBY_WIFI_DIRECT_NULL_SSID + 379, // 4529 -> NEARBY_WIFI_DIRECT_NULL_PASSWORD + 306, // 4530 -> NEARBY_BT_MULTIPLEX_SOCKET_DISABLED + 339, // 4531 -> NEARBY_LAN_MULTIPLEX_SOCKET_DISABLED + 320, // 4532 -> NEARBY_GENERIC_NEW_ENDPOINT_CHANNEL_NULL + 377, // 4533 -> NEARBY_WIFI_DIRECT_NO_GROUP_FOR_LISTENING + 391, // 4534 -> NEARBY_WIFI_HOTSPOT_NO_HOTSPOT_FOR_LISTENING + 321, // 4535 -> NEARBY_GENERIC_OLD_ENDPOINT_CHANNEL_NULL + 299, // 4536 -> NEARBY_BLE_OPERATION_REGISTERED_FAILED + 336, // 4537 -> NEARBY_L2CAP_OPERATION_REGISTERED_FAILED + 308, // 4538 -> NEARBY_BT_OPERATION_REGISTERED_FAILED + 341, // 4539 -> NEARBY_LAN_OPERATION_REGISTERED_FAILED + 367, // 4540 -> NEARBY_WEB_RTC_OPERATION_REGISTERED_FAILED + 373, // 4541 -> NEARBY_WIFI_AWARE_OPERATION_REGISTERED_FAILED + 387, // 4542 -> NEARBY_WIFI_HOTSPOT_DIRECT_OPERATION_REGISTERED_FAILED + 397, // 4543 -> NEARBY_WIFI_HOTSPOT_SOFT_AP_OPERATION_REGISTERED_FAILED + 390, // 4544 -> NEARBY_WIFI_HOTSPOT_LOHS_OPERATION_REGISTERED_FAILED + 386, // 4545 -> NEARBY_WIFI_HOTSPOT_CLIENT_OPERATION_REGISTERED_FAILED + 381, // 4546 -> NEARBY_WIFI_DIRECT_OPERATION_REGISTERED_FAILED + 322, // 4547 -> NEARBY_GENERIC_OUTGOING_PAYLOAD_CREATION_FAILURE + 393, // 4548 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_2G_BUT_AP_5G + 382, // 4549 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_2G_BUT_AP_5G + 394, // 4550 -> NEARBY_WIFI_HOTSPOT_P2P_NON_DBS_WANT_5G_BUT_AP_2G + 383, // 4551 -> NEARBY_WIFI_DIRECT_P2P_NON_DBS_WANT_5G_BUT_AP_2G + 319, // 4552 -> NEARBY_GENERIC_INCOMING_PAYLOAD_NOT_DATA_TYPE + 326, // 4553 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_EVENT_TYPE_ERROR + 328, // 4554 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FRAME_TYPE_ERROR + 327, // 4555 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_FORMAT_ERROR + 323, // 4556 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_EVENT_TYPE_ERROR + 325, // 4557 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FRAME_TYPE_ERROR + 324, // 4558 -> NEARBY_GENERIC_READ_CLIENT_INTRODUCTION_ACK_FORMAT_ERROR + 329, // 4559 -> NEARBY_GENERIC_REMOTE_ENDPOINT_STATUS_ERROR + 330, // 4560 -> NEARBY_GENERIC_REMOTE_REPORT_PAYLOADS_ERROR + 331, // 4561 -> NEARBY_GENERIC_REMOTE_UPGRADE_FAILURE + 332, // 4562 -> NEARBY_GENERIC_SEND_PAYLOAD_EXECUTOR_NULL + 309, // 4563 -> NEARBY_BT_VIRTUAL_SOCKET_CREATION_FAILURE + 344, // 4564 -> NEARBY_LAN_VIRTUAL_SOCKET_CREATION_FAILURE + 400, // 4565 -> NEARBY_WIFI_LAN_IP_ADDRESS_ERROR + 337, // 4566 -> NEARBY_L2CAP_PSM_NOT_POSITIVE + 314, // 4567 -> NEARBY_ENCRYPTION_FAILURE + 288, // 4568 -> NEARBY_AUTHENTICATION_FAILURE + 345, // 4569 -> NEARBY_LAN_VIRTUAL_SOCKET_NULL + 300, // 4570 -> NEARBY_BLUETOOTH_ADVERTISE_TO_BYTES_FAILURE + 293, // 4571 -> NEARBY_BLE_ADVERTISE_TO_BYTES_FAILURE + 295, // 4572 -> NEARBY_BLE_FAST_ADVERTISE_TO_BYTES_FAILURE + 348, // 4573 -> NEARBY_NFC_ADVERTISE_TO_BYTES_FAILURE + 398, // 4574 -> NEARBY_WIFI_LAN_ADVERTISE_TO_BYTES_FAILURE + 369, // 4575 -> NEARBY_WIFI_AWARE_ADVERTISE_TO_BYTES_FAILURE + 357, // 4576 -> NEARBY_USB_ADVERTISE_TO_BYTES_FAILURE + 350, // 4577 -> NEARBY_NFC_INVALID_PCP_OPTIONS + 301, // 4578 -> NEARBY_BLUETOOTH_INVALID_PCP_OPTIONS + 298, // 4579 -> NEARBY_BLE_INVALID_PCP_OPTIONS + 399, // 4580 -> NEARBY_WIFI_LAN_INVALID_PCP_OPTIONS + 371, // 4581 -> NEARBY_WIFI_AWARE_INVALID_PCP_OPTIONS + 359, // 4582 -> NEARBY_USB_INVALID_PCP_OPTIONS + 361, // 4583 -> NEARBY_UWB_INVALID_PCP_OPTIONS + 364, // 4584 -> NEARBY_WEB_RTC_INVALID_PCP_OPTIONS + 303, // 4585 -> NEARBY_BLUETOOTH_NO_CLIENT_REGISTER_FOR_SCAN + 333, // 4586 -> NEARBY_INSTANT_CONNECTION_WRONG_CONNECTIVITY_INFO + 347, // 4587 -> NEARBY_NEED_METHOD_OVERRIDE + 318, // 4588 -> NEARBY_GENERIC_INCOMING_PAYLOAD_CREATION_FAILURE + 365, // 4589 -> NEARBY_WEB_RTC_NO_LISTENING_PEER_FOUND + 356, // 4590 -> NEARBY_UPGRADE_PATH_ON_WRONG_MEDIUM + 313, // 4591 -> NEARBY_CONNECT_TO_ALL_MEDIUMS_FAILURE + 304, // 4592 -> NEARBY_BLUETOOTH_RECONNECT_MAC_NULL + 342, // 4593 -> NEARBY_LAN_RECONNECT_CONNECTION_INFO_NULL + 343, // 4594 -> NEARBY_LAN_RECONNECT_IP_NULL + 385, // 4595 -> NEARBY_WIFI_DIRECT_RECONNECT_META_DATA_NULL + 384, // 4596 -> NEARBY_WIFI_DIRECT_RECONNECT_CONNECT_META_DATA_NULL + 396, // 4597 -> NEARBY_WIFI_HOTSPOT_RECONNECT_META_DATA_NULL + 395, // 4598 -> NEARBY_WIFI_HOTSPOT_RECONNECT_CONNECT_META_DATA_NULL + 368, // 4599 -> NEARBY_WEB_RTC_RECONNECT_PEER_ID_NULL + 374, // 4600 -> NEARBY_WIFI_AWARE_RECONNECT_META_DATA_NULL + 352, // 4601 -> NEARBY_NOT_ADVERTISING_OR_LISTENING + 310, // 4602 -> NEARBY_CAN_NOT_OBTAIN_DEVICE_PROVIDER + 354, // 4603 -> NEARBY_SETUP_STRATEGY_FAILURE + 355, // 4604 -> NEARBY_TX_ADVERTISEMENT_NULL + 315, // 4605 -> NEARBY_ENDPOINT_ID_MISMATCH + 312, // 4606 -> NEARBY_CONNECTIVITY_INFO_NULL_OR_WRONG + 346, // 4607 -> NEARBY_LOCAL_CLIENT_STATE_WRONG + 353, // 4608 -> NEARBY_REMOTE_EXCEPTION_WHEN_PROCESSING_RECEIVED_PAYLOAD + 291, // 4609 -> NEARBY_BAD_FILE_DESCRIPTION_WHEN_PROCESSING_RECEIVED_PAYLOAD + 311, // 4610 -> NEARBY_CONNECTION_LISTENER_NULL + 289, // 4611 -> NEARBY_AWDL_ADVERTISE_TO_BYTES_FAILURE + 290, // 4612 -> NEARBY_AWDL_ENDPOINT_CHANNEL_CREATION_FAILURE + 177, // 5000 -> DCT_ERROR_BLE_DISABLED + 176, // 5001 -> DCT_ERROR_BLE_ADV_FAILED + 178, // 5002 -> DCT_ERROR_BLE_SCAN_FAILED + 187, // 5003 -> DCT_ERROR_L2CAP_SERVER_FAILED + 186, // 5004 -> DCT_ERROR_L2CAP_CLIENT_FAILED + 188, // 5005 -> DCT_ERROR_MDNS_DISCOVERY_TIMEOUT + 189, // 5006 -> DCT_ERROR_MDNS_REGISTER_SERVICE + 184, // 5007 -> DCT_ERROR_INITIAL_TLS_SPAKE + 193, // 5008 -> DCT_ERROR_SUBSEQUENT_TLS_SPAKE + 190, // 5009 -> DCT_ERROR_REQUEST_FAILED + 191, // 5010 -> DCT_ERROR_RESPONSE_FAILED + 180, // 5011 -> DCT_ERROR_CONTROL_MESSAGE_EXCHANGE + 179, // 5012 -> DCT_ERROR_CAPABILITY_MISMATCH + 182, // 5013 -> DCT_ERROR_HIGH_SPEED_MEDIUM_UNAVAILABLE + 198, // 5014 -> DCT_ERROR_WIFI_DISABLED + 199, // 5015 -> DCT_ERROR_WIFI_DISCONNECTED + 197, // 5016 -> DCT_ERROR_WIFI_CREDENTIAL_TRANSFER + 200, // 5017 -> DCT_ERROR_WIFI_INTERNET_CONNECTION + 195, // 5018 -> DCT_ERROR_UPGRADE_HIGH_SPEED_MEDIUM_FAILED + 185, // 5019 -> DCT_ERROR_KEEPALIVE_TIMEOUT + 181, // 5020 -> DCT_ERROR_ESTABLISHED_CONNECTION_LOST + 196, // 5021 -> DCT_ERROR_USER_CANCELLED + 192, // 5022 -> DCT_ERROR_SERVICE_CANCELLED + 194, // 5023 -> DCT_ERROR_UNVERIFIED_INTEGRITY + 183, // 5024 -> DCT_ERROR_HTTP_SERVER_CLOSED }; const std::string& OperationResultCode_Name( @@ -3259,12 +3330,12 @@ const std::string& OperationResultCode_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( OperationResultCode_entries, OperationResultCode_entries_by_number, - 397, OperationResultCode_strings); + 401, OperationResultCode_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( OperationResultCode_entries, OperationResultCode_entries_by_number, - 397, value); + 401, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : OperationResultCode_strings[idx].get(); } @@ -3272,7 +3343,7 @@ bool OperationResultCode_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultCode* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - OperationResultCode_entries, 397, name, &int_value); + OperationResultCode_entries, 401, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -3447,6 +3518,128 @@ bool DeviceType_Parse( } return success; } +bool SupportedService_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed SupportedService_strings[4] = {}; + +static const char SupportedService_names[] = + "SUPPORTED_SERVICE_DATA_MIGRATION" + "SUPPORTED_SERVICE_DATA_TRANSFER" + "SUPPORTED_SERVICE_SETTINGS_ESIM" + "SUPPORTED_SERVICE_UNSPECIFIED"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SupportedService_entries[] = { + { {SupportedService_names + 0, 32}, 2 }, + { {SupportedService_names + 32, 31}, 3 }, + { {SupportedService_names + 63, 31}, 1 }, + { {SupportedService_names + 94, 29}, 0 }, +}; + +static const int SupportedService_entries_by_number[] = { + 3, // 0 -> SUPPORTED_SERVICE_UNSPECIFIED + 2, // 1 -> SUPPORTED_SERVICE_SETTINGS_ESIM + 0, // 2 -> SUPPORTED_SERVICE_DATA_MIGRATION + 1, // 3 -> SUPPORTED_SERVICE_DATA_TRANSFER +}; + +const std::string& SupportedService_Name( + SupportedService value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + SupportedService_entries, + SupportedService_entries_by_number, + 4, SupportedService_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + SupportedService_entries, + SupportedService_entries_by_number, + 4, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + SupportedService_strings[idx].get(); +} +bool SupportedService_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SupportedService* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + SupportedService_entries, 4, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool DctPayloadType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed DctPayloadType_strings[5] = {}; + +static const char DctPayloadType_names[] = + "DCT_PAYLOAD_TYPE_BYTES_RESPONSE" + "DCT_PAYLOAD_TYPE_FILES_RESPONSE" + "DCT_PAYLOAD_TYPE_ONE_WAY_MESSAGE" + "DCT_PAYLOAD_TYPE_REQUEST" + "DCT_PAYLOAD_TYPE_UNSPECIFIED"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DctPayloadType_entries[] = { + { {DctPayloadType_names + 0, 31}, 2 }, + { {DctPayloadType_names + 31, 31}, 3 }, + { {DctPayloadType_names + 62, 32}, 4 }, + { {DctPayloadType_names + 94, 24}, 1 }, + { {DctPayloadType_names + 118, 28}, 0 }, +}; + +static const int DctPayloadType_entries_by_number[] = { + 4, // 0 -> DCT_PAYLOAD_TYPE_UNSPECIFIED + 3, // 1 -> DCT_PAYLOAD_TYPE_REQUEST + 0, // 2 -> DCT_PAYLOAD_TYPE_BYTES_RESPONSE + 1, // 3 -> DCT_PAYLOAD_TYPE_FILES_RESPONSE + 2, // 4 -> DCT_PAYLOAD_TYPE_ONE_WAY_MESSAGE +}; + +const std::string& DctPayloadType_Name( + DctPayloadType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + DctPayloadType_entries, + DctPayloadType_entries_by_number, + 5, DctPayloadType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + DctPayloadType_entries, + DctPayloadType_entries_by_number, + 5, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + DctPayloadType_strings[idx].get(); +} +bool DctPayloadType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DctPayloadType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + DctPayloadType_entries, 5, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} // @@protoc_insertion_point(namespace_scope) } // namespace connections diff --git a/compiled_proto/proto/connections_enums.pb.h b/compiled_proto/proto/connections_enums.pb.h index 7bac772e..a1708e54 100644 --- a/compiled_proto/proto/connections_enums.pb.h +++ b/compiled_proto/proto/connections_enums.pb.h @@ -13,7 +13,7 @@ #error incompatible with your Protocol Buffer headers. Please update #error your headers. #endif -#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019005 < 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. @@ -155,6 +155,26 @@ inline const std::string& Medium_Name(T enum_t_value) { } bool Medium_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Medium* value); +enum WifiDirectAuthType : int { + WIFI_DIRECT_TYPE_UNKNOWN = 0, + WIFI_DIRECT_WITH_PASSWORD = 1, + WIFI_DIRECT_WITH_PIN = 2 +}; +bool WifiDirectAuthType_IsValid(int value); +constexpr WifiDirectAuthType WifiDirectAuthType_MIN = WIFI_DIRECT_TYPE_UNKNOWN; +constexpr WifiDirectAuthType WifiDirectAuthType_MAX = WIFI_DIRECT_WITH_PIN; +constexpr int WifiDirectAuthType_ARRAYSIZE = WifiDirectAuthType_MAX + 1; + +const std::string& WifiDirectAuthType_Name(WifiDirectAuthType value); +template +inline const std::string& WifiDirectAuthType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function WifiDirectAuthType_Name."); + return WifiDirectAuthType_Name(static_cast(enum_t_value)); +} +bool WifiDirectAuthType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WifiDirectAuthType* value); enum ConnectionTechnology : int { CONNECTION_TECHNOLOGY_UNKNOWN_TECHNOLOGY = 0, CONNECTION_TECHNOLOGY_BLE_GATT = 1, @@ -854,6 +874,10 @@ enum OperationResultCode : int { CONNECTIVITY_AWDL_INVALID_CREDENTIAL = 3604, CONNECTIVITY_AWDL_CLIENT_SOCKET_CREATION_FAILURE = 3605, CONNECTIVITY_CHANNEL_IO_ERROR_ON_AWDL = 3606, + CONNECTIVITY_WIFI_AWARE_DO_UNAVAILABLE = 3607, + CONNECTIVITY_WIFI_AWARE_DISCOVER_PEER_NULL_SCREEN_OFF = 3608, + CONNECTIVITY_WIFI_AWARE_DISCOVER_PEER_NULL_TIMEOUT = 3609, + CONNECTIVITY_WIFI_AWARE_JOIN_NETWORK_FAILED = 3610, NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR = 4500, NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT = 4501, NEARBY_WEB_RTC_CONNECTION_FLOW_NULL = 4502, @@ -1069,6 +1093,49 @@ inline const std::string& DeviceType_Name(T enum_t_value) { } bool DeviceType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceType* value); +enum SupportedService : int { + SUPPORTED_SERVICE_UNSPECIFIED = 0, + SUPPORTED_SERVICE_SETTINGS_ESIM = 1, + SUPPORTED_SERVICE_DATA_MIGRATION = 2, + SUPPORTED_SERVICE_DATA_TRANSFER = 3 +}; +bool SupportedService_IsValid(int value); +constexpr SupportedService SupportedService_MIN = SUPPORTED_SERVICE_UNSPECIFIED; +constexpr SupportedService SupportedService_MAX = SUPPORTED_SERVICE_DATA_TRANSFER; +constexpr int SupportedService_ARRAYSIZE = SupportedService_MAX + 1; + +const std::string& SupportedService_Name(SupportedService value); +template +inline const std::string& SupportedService_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SupportedService_Name."); + return SupportedService_Name(static_cast(enum_t_value)); +} +bool SupportedService_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SupportedService* value); +enum DctPayloadType : int { + DCT_PAYLOAD_TYPE_UNSPECIFIED = 0, + DCT_PAYLOAD_TYPE_REQUEST = 1, + DCT_PAYLOAD_TYPE_BYTES_RESPONSE = 2, + DCT_PAYLOAD_TYPE_FILES_RESPONSE = 3, + DCT_PAYLOAD_TYPE_ONE_WAY_MESSAGE = 4 +}; +bool DctPayloadType_IsValid(int value); +constexpr DctPayloadType DctPayloadType_MIN = DCT_PAYLOAD_TYPE_UNSPECIFIED; +constexpr DctPayloadType DctPayloadType_MAX = DCT_PAYLOAD_TYPE_ONE_WAY_MESSAGE; +constexpr int DctPayloadType_ARRAYSIZE = DctPayloadType_MAX + 1; + +const std::string& DctPayloadType_Name(DctPayloadType value); +template +inline const std::string& DctPayloadType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DctPayloadType_Name."); + return DctPayloadType_Name(static_cast(enum_t_value)); +} +bool DctPayloadType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DctPayloadType* value); // =================================================================== @@ -1098,6 +1165,7 @@ template <> struct is_proto_enum< ::location::nearby::proto::connections::EventT template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionsStrategy> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::connections::SessionRole> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::connections::Medium> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::connections::WifiDirectAuthType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionTechnology> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionBand> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionMode> : ::std::true_type {}; @@ -1119,6 +1187,8 @@ template <> struct is_proto_enum< ::location::nearby::proto::connections::Operat template <> struct is_proto_enum< ::location::nearby::proto::connections::StopAdvertisingReason> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::connections::StopDiscoveringReason> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::connections::DeviceType> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::connections::SupportedService> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::connections::DctPayloadType> : ::std::true_type {}; PROTOBUF_NAMESPACE_CLOSE diff --git a/compiled_proto/proto/sharing_enums.pb.cc b/compiled_proto/proto/sharing_enums.pb.cc index f3b78c1f..4b1608a6 100644 --- a/compiled_proto/proto/sharing_enums.pb.cc +++ b/compiled_proto/proto/sharing_enums.pb.cc @@ -100,13 +100,20 @@ bool EventType_IsValid(int value) { case 71: case 72: case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed EventType_strings[74] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed EventType_strings[81] = {}; static const char EventType_names[] = "ACCEPT_AGREEMENTS" @@ -120,6 +127,13 @@ static const char EventType_names[] = "CANCEL_CONNECTION" "CANCEL_RECEIVING_ATTACHMENTS" "CANCEL_SENDING_ATTACHMENTS" + "CLOUD_CREATE_SHARING_REQUEST" + "CLOUD_DOWNLOAD_END" + "CLOUD_DOWNLOAD_START" + "CLOUD_REGISTER_RECEIVER" + "CLOUD_SHARING_RPC_RESULT" + "CLOUD_UPLOAD_END" + "CLOUD_UPLOAD_START" "DECLINE_AGREEMENTS" "DECRYPT_CERTIFICATE_FAILURE" "DEFAULT_OPT_IN" @@ -196,146 +210,160 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EventType_entries[] = { {EventType_names + 178, 17}, 30 }, { {EventType_names + 195, 28}, 20 }, { {EventType_names + 223, 26}, 19 }, - { {EventType_names + 249, 18}, 46 }, - { {EventType_names + 267, 27}, 64 }, - { {EventType_names + 294, 14}, 56 }, - { {EventType_names + 308, 20}, 4 }, - { {EventType_names + 328, 15}, 49 }, - { {EventType_names + 343, 21}, 11 }, - { {EventType_names + 364, 27}, 29 }, - { {EventType_names + 391, 28}, 32 }, - { {EventType_names + 419, 21}, 54 }, - { {EventType_names + 440, 28}, 53 }, - { {EventType_names + 468, 21}, 2 }, - { {EventType_names + 489, 20}, 48 }, - { {EventType_names + 509, 25}, 61 }, - { {EventType_names + 534, 26}, 25 }, - { {EventType_names + 560, 16}, 72 }, - { {EventType_names + 576, 25}, 68 }, - { {EventType_names + 601, 11}, 40 }, - { {EventType_names + 612, 15}, 31 }, - { {EventType_names + 627, 14}, 42 }, - { {EventType_names + 641, 20}, 38 }, - { {EventType_names + 661, 21}, 22 }, - { {EventType_names + 682, 25}, 21 }, - { {EventType_names + 707, 26}, 60 }, - { {EventType_names + 733, 17}, 55 }, - { {EventType_names + 750, 32}, 43 }, - { {EventType_names + 782, 18}, 59 }, - { {EventType_names + 800, 28}, 71 }, - { {EventType_names + 828, 23}, 18 }, - { {EventType_names + 851, 25}, 17 }, - { {EventType_names + 876, 27}, 10 }, - { {EventType_names + 903, 20}, 13 }, - { {EventType_names + 923, 16}, 73 }, - { {EventType_names + 939, 14}, 24 }, - { {EventType_names + 953, 26}, 37 }, - { {EventType_names + 979, 27}, 47 }, - { {EventType_names + 1006, 23}, 14 }, - { {EventType_names + 1029, 15}, 69 }, - { {EventType_names + 1044, 26}, 6 }, - { {EventType_names + 1070, 28}, 5 }, - { {EventType_names + 1098, 20}, 16 }, - { {EventType_names + 1118, 22}, 15 }, - { {EventType_names + 1140, 25}, 62 }, - { {EventType_names + 1165, 27}, 66 }, - { {EventType_names + 1192, 24}, 9 }, - { {EventType_names + 1216, 17}, 12 }, - { {EventType_names + 1233, 10}, 26 }, - { {EventType_names + 1243, 12}, 57 }, - { {EventType_names + 1255, 11}, 63 }, - { {EventType_names + 1266, 14}, 28 }, - { {EventType_names + 1280, 15}, 45 }, - { {EventType_names + 1295, 14}, 3 }, - { {EventType_names + 1309, 33}, 65 }, - { {EventType_names + 1342, 21}, 70 }, - { {EventType_names + 1363, 12}, 35 }, - { {EventType_names + 1375, 8}, 34 }, - { {EventType_names + 1383, 24}, 33 }, - { {EventType_names + 1407, 11}, 58 }, - { {EventType_names + 1418, 29}, 52 }, - { {EventType_names + 1447, 23}, 39 }, - { {EventType_names + 1470, 24}, 44 }, - { {EventType_names + 1494, 18}, 0 }, - { {EventType_names + 1512, 10}, 41 }, - { {EventType_names + 1522, 18}, 67 }, + { {EventType_names + 249, 28}, 74 }, + { {EventType_names + 277, 18}, 79 }, + { {EventType_names + 295, 20}, 78 }, + { {EventType_names + 315, 23}, 75 }, + { {EventType_names + 338, 24}, 80 }, + { {EventType_names + 362, 16}, 77 }, + { {EventType_names + 378, 18}, 76 }, + { {EventType_names + 396, 18}, 46 }, + { {EventType_names + 414, 27}, 64 }, + { {EventType_names + 441, 14}, 56 }, + { {EventType_names + 455, 20}, 4 }, + { {EventType_names + 475, 15}, 49 }, + { {EventType_names + 490, 21}, 11 }, + { {EventType_names + 511, 27}, 29 }, + { {EventType_names + 538, 28}, 32 }, + { {EventType_names + 566, 21}, 54 }, + { {EventType_names + 587, 28}, 53 }, + { {EventType_names + 615, 21}, 2 }, + { {EventType_names + 636, 20}, 48 }, + { {EventType_names + 656, 25}, 61 }, + { {EventType_names + 681, 26}, 25 }, + { {EventType_names + 707, 16}, 72 }, + { {EventType_names + 723, 25}, 68 }, + { {EventType_names + 748, 11}, 40 }, + { {EventType_names + 759, 15}, 31 }, + { {EventType_names + 774, 14}, 42 }, + { {EventType_names + 788, 20}, 38 }, + { {EventType_names + 808, 21}, 22 }, + { {EventType_names + 829, 25}, 21 }, + { {EventType_names + 854, 26}, 60 }, + { {EventType_names + 880, 17}, 55 }, + { {EventType_names + 897, 32}, 43 }, + { {EventType_names + 929, 18}, 59 }, + { {EventType_names + 947, 28}, 71 }, + { {EventType_names + 975, 23}, 18 }, + { {EventType_names + 998, 25}, 17 }, + { {EventType_names + 1023, 27}, 10 }, + { {EventType_names + 1050, 20}, 13 }, + { {EventType_names + 1070, 16}, 73 }, + { {EventType_names + 1086, 14}, 24 }, + { {EventType_names + 1100, 26}, 37 }, + { {EventType_names + 1126, 27}, 47 }, + { {EventType_names + 1153, 23}, 14 }, + { {EventType_names + 1176, 15}, 69 }, + { {EventType_names + 1191, 26}, 6 }, + { {EventType_names + 1217, 28}, 5 }, + { {EventType_names + 1245, 20}, 16 }, + { {EventType_names + 1265, 22}, 15 }, + { {EventType_names + 1287, 25}, 62 }, + { {EventType_names + 1312, 27}, 66 }, + { {EventType_names + 1339, 24}, 9 }, + { {EventType_names + 1363, 17}, 12 }, + { {EventType_names + 1380, 10}, 26 }, + { {EventType_names + 1390, 12}, 57 }, + { {EventType_names + 1402, 11}, 63 }, + { {EventType_names + 1413, 14}, 28 }, + { {EventType_names + 1427, 15}, 45 }, + { {EventType_names + 1442, 14}, 3 }, + { {EventType_names + 1456, 33}, 65 }, + { {EventType_names + 1489, 21}, 70 }, + { {EventType_names + 1510, 12}, 35 }, + { {EventType_names + 1522, 8}, 34 }, + { {EventType_names + 1530, 24}, 33 }, + { {EventType_names + 1554, 11}, 58 }, + { {EventType_names + 1565, 29}, 52 }, + { {EventType_names + 1594, 23}, 39 }, + { {EventType_names + 1617, 24}, 44 }, + { {EventType_names + 1641, 18}, 0 }, + { {EventType_names + 1659, 10}, 41 }, + { {EventType_names + 1669, 18}, 67 }, }; static const int EventType_entries_by_number[] = { - 71, // 0 -> UNKNOWN_EVENT_TYPE + 78, // 0 -> UNKNOWN_EVENT_TYPE 0, // 1 -> ACCEPT_AGREEMENTS - 21, // 2 -> ENABLE_NEARBY_SHARING - 61, // 3 -> SET_VISIBILITY - 14, // 4 -> DESCRIBE_ATTACHMENTS - 49, // 5 -> SCAN_FOR_SHARE_TARGETS_START - 48, // 6 -> SCAN_FOR_SHARE_TARGETS_END + 28, // 2 -> ENABLE_NEARBY_SHARING + 68, // 3 -> SET_VISIBILITY + 21, // 4 -> DESCRIBE_ATTACHMENTS + 56, // 5 -> SCAN_FOR_SHARE_TARGETS_START + 55, // 6 -> SCAN_FOR_SHARE_TARGETS_END 5, // 7 -> ADVERTISE_DEVICE_PRESENCE_START 4, // 8 -> ADVERTISE_DEVICE_PRESENCE_END - 54, // 9 -> SEND_FAST_INITIALIZATION - 40, // 10 -> RECEIVE_FAST_INITIALIZATION - 16, // 11 -> DISCOVER_SHARE_TARGET - 55, // 12 -> SEND_INTRODUCTION - 41, // 13 -> RECEIVE_INTRODUCTION - 46, // 14 -> RESPOND_TO_INTRODUCTION - 51, // 15 -> SEND_ATTACHMENTS_START - 50, // 16 -> SEND_ATTACHMENTS_END - 39, // 17 -> RECEIVE_ATTACHMENTS_START - 38, // 18 -> RECEIVE_ATTACHMENTS_END + 61, // 9 -> SEND_FAST_INITIALIZATION + 47, // 10 -> RECEIVE_FAST_INITIALIZATION + 23, // 11 -> DISCOVER_SHARE_TARGET + 62, // 12 -> SEND_INTRODUCTION + 48, // 13 -> RECEIVE_INTRODUCTION + 53, // 14 -> RESPOND_TO_INTRODUCTION + 58, // 15 -> SEND_ATTACHMENTS_START + 57, // 16 -> SEND_ATTACHMENTS_END + 46, // 17 -> RECEIVE_ATTACHMENTS_START + 45, // 18 -> RECEIVE_ATTACHMENTS_END 10, // 19 -> CANCEL_SENDING_ATTACHMENTS 9, // 20 -> CANCEL_RECEIVING_ATTACHMENTS - 32, // 21 -> OPEN_RECEIVED_ATTACHMENTS - 31, // 22 -> LAUNCH_SETUP_ACTIVITY + 39, // 21 -> OPEN_RECEIVED_ATTACHMENTS + 38, // 22 -> LAUNCH_SETUP_ACTIVITY 2, // 23 -> ADD_CONTACT - 43, // 24 -> REMOVE_CONTACT - 24, // 25 -> FAST_SHARE_SERVER_RESPONSE - 56, // 26 -> SEND_START + 50, // 24 -> REMOVE_CONTACT + 31, // 25 -> FAST_SHARE_SERVER_RESPONSE + 63, // 26 -> SEND_START 1, // 27 -> ACCEPT_FAST_INITIALIZATION - 59, // 28 -> SET_DATA_USAGE - 17, // 29 -> DISMISS_FAST_INITIALIZATION + 66, // 28 -> SET_DATA_USAGE + 24, // 29 -> DISMISS_FAST_INITIALIZATION 8, // 30 -> CANCEL_CONNECTION - 28, // 31 -> LAUNCH_ACTIVITY - 18, // 32 -> DISMISS_PRIVACY_NOTIFICATION - 66, // 33 -> TAP_PRIVACY_NOTIFICATION - 65, // 34 -> TAP_HELP - 64, // 35 -> TAP_FEEDBACK + 35, // 31 -> LAUNCH_ACTIVITY + 25, // 32 -> DISMISS_PRIVACY_NOTIFICATION + 73, // 33 -> TAP_PRIVACY_NOTIFICATION + 72, // 34 -> TAP_HELP + 71, // 35 -> TAP_FEEDBACK 3, // 36 -> ADD_QUICK_SETTINGS_TILE - 44, // 37 -> REMOVE_QUICK_SETTINGS_TILE - 30, // 38 -> LAUNCH_PHONE_CONSENT - 69, // 39 -> TAP_QUICK_SETTINGS_TILE - 27, // 40 -> INSTALL_APK - 72, // 41 -> VERIFY_APK - 29, // 42 -> LAUNCH_CONSENT - 35, // 43 -> PROCESS_RECEIVED_ATTACHMENTS_END - 70, // 44 -> TOGGLE_SHOW_NOTIFICATION - 60, // 45 -> SET_DEVICE_NAME - 11, // 46 -> DECLINE_AGREEMENTS - 45, // 47 -> REQUEST_SETTING_PERMISSIONS - 22, // 48 -> ESTABLISH_CONNECTION - 15, // 49 -> DEVICE_SETTINGS + 51, // 37 -> REMOVE_QUICK_SETTINGS_TILE + 37, // 38 -> LAUNCH_PHONE_CONSENT + 76, // 39 -> TAP_QUICK_SETTINGS_TILE + 34, // 40 -> INSTALL_APK + 79, // 41 -> VERIFY_APK + 36, // 42 -> LAUNCH_CONSENT + 42, // 43 -> PROCESS_RECEIVED_ATTACHMENTS_END + 77, // 44 -> TOGGLE_SHOW_NOTIFICATION + 67, // 45 -> SET_DEVICE_NAME + 18, // 46 -> DECLINE_AGREEMENTS + 52, // 47 -> REQUEST_SETTING_PERMISSIONS + 29, // 48 -> ESTABLISH_CONNECTION + 22, // 49 -> DEVICE_SETTINGS 7, // 50 -> AUTO_DISMISS_FAST_INITIALIZATION 6, // 51 -> APP_CRASH - 68, // 52 -> TAP_QUICK_SETTINGS_FILE_SHARE - 20, // 53 -> DISPLAY_PRIVACY_NOTIFICATION - 19, // 54 -> DISPLAY_PHONE_CONSENT - 34, // 55 -> PREFERENCES_USAGE - 13, // 56 -> DEFAULT_OPT_IN - 57, // 57 -> SETUP_WIZARD - 67, // 58 -> TAP_QR_CODE - 36, // 59 -> QR_CODE_LINK_SHOWN - 33, // 60 -> PARSING_FAILED_ENDPOINT_ID - 23, // 61 -> FAST_INIT_DISCOVER_DEVICE - 52, // 62 -> SEND_DESKTOP_NOTIFICATION - 58, // 63 -> SET_ACCOUNT - 12, // 64 -> DECRYPT_CERTIFICATE_FAILURE - 62, // 65 -> SHOW_ALLOW_PERMISSION_AUTO_ACCESS - 53, // 66 -> SEND_DESKTOP_TRANSFER_EVENT - 73, // 67 -> WAITING_FOR_ACCEPT - 26, // 68 -> HIGH_QUALITY_MEDIUM_SETUP - 47, // 69 -> RPC_CALL_STATUS - 63, // 70 -> START_QR_CODE_SESSION - 37, // 71 -> QR_CODE_OPENED_IN_WEB_CLIENT - 25, // 72 -> HATS_JOINT_EVENT - 42, // 73 -> RECEIVE_PREVIEWS + 75, // 52 -> TAP_QUICK_SETTINGS_FILE_SHARE + 27, // 53 -> DISPLAY_PRIVACY_NOTIFICATION + 26, // 54 -> DISPLAY_PHONE_CONSENT + 41, // 55 -> PREFERENCES_USAGE + 20, // 56 -> DEFAULT_OPT_IN + 64, // 57 -> SETUP_WIZARD + 74, // 58 -> TAP_QR_CODE + 43, // 59 -> QR_CODE_LINK_SHOWN + 40, // 60 -> PARSING_FAILED_ENDPOINT_ID + 30, // 61 -> FAST_INIT_DISCOVER_DEVICE + 59, // 62 -> SEND_DESKTOP_NOTIFICATION + 65, // 63 -> SET_ACCOUNT + 19, // 64 -> DECRYPT_CERTIFICATE_FAILURE + 69, // 65 -> SHOW_ALLOW_PERMISSION_AUTO_ACCESS + 60, // 66 -> SEND_DESKTOP_TRANSFER_EVENT + 80, // 67 -> WAITING_FOR_ACCEPT + 33, // 68 -> HIGH_QUALITY_MEDIUM_SETUP + 54, // 69 -> RPC_CALL_STATUS + 70, // 70 -> START_QR_CODE_SESSION + 44, // 71 -> QR_CODE_OPENED_IN_WEB_CLIENT + 32, // 72 -> HATS_JOINT_EVENT + 49, // 73 -> RECEIVE_PREVIEWS + 11, // 74 -> CLOUD_CREATE_SHARING_REQUEST + 14, // 75 -> CLOUD_REGISTER_RECEIVER + 17, // 76 -> CLOUD_UPLOAD_START + 16, // 77 -> CLOUD_UPLOAD_END + 13, // 78 -> CLOUD_DOWNLOAD_START + 12, // 79 -> CLOUD_DOWNLOAD_END + 15, // 80 -> CLOUD_SHARING_RPC_RESULT }; const std::string& EventType_Name( @@ -344,12 +372,12 @@ const std::string& EventType_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( EventType_entries, EventType_entries_by_number, - 74, EventType_strings); + 81, EventType_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( EventType_entries, EventType_entries_by_number, - 74, value); + 81, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : EventType_strings[idx].get(); } @@ -357,7 +385,7 @@ bool EventType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventType* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - EventType_entries, 74, name, &int_value); + EventType_entries, 81, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -1643,15 +1671,17 @@ bool SyncPurpose_IsValid(int value) { case 15: case 16: case 17: + case 18: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed SyncPurpose_strings[18] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed SyncPurpose_strings[19] = {}; static const char SyncPurpose_names[] = + "SYNC_EXHAUST_SALT" "SYNC_PURPOSE_ACCOUNT_CHANGE" "SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN" "SYNC_PURPOSE_CHIME_NOTIFICATION" @@ -1672,45 +1702,47 @@ static const char SyncPurpose_names[] = "SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE"; static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SyncPurpose_entries[] = { - { {SyncPurpose_names + 0, 27}, 15 }, - { {SyncPurpose_names + 27, 33}, 5 }, - { {SyncPurpose_names + 60, 31}, 2 }, - { {SyncPurpose_names + 91, 32}, 11 }, - { {SyncPurpose_names + 123, 23}, 3 }, - { {SyncPurpose_names + 146, 43}, 17 }, - { {SyncPurpose_names + 189, 33}, 6 }, - { {SyncPurpose_names + 222, 27}, 1 }, - { {SyncPurpose_names + 249, 30}, 4 }, - { {SyncPurpose_names + 279, 36}, 16 }, - { {SyncPurpose_names + 315, 47}, 13 }, - { {SyncPurpose_names + 362, 27}, 12 }, - { {SyncPurpose_names + 389, 34}, 10 }, - { {SyncPurpose_names + 423, 30}, 8 }, - { {SyncPurpose_names + 453, 30}, 7 }, - { {SyncPurpose_names + 483, 45}, 9 }, - { {SyncPurpose_names + 528, 20}, 0 }, - { {SyncPurpose_names + 548, 47}, 14 }, + { {SyncPurpose_names + 0, 17}, 18 }, + { {SyncPurpose_names + 17, 27}, 15 }, + { {SyncPurpose_names + 44, 33}, 5 }, + { {SyncPurpose_names + 77, 31}, 2 }, + { {SyncPurpose_names + 108, 32}, 11 }, + { {SyncPurpose_names + 140, 23}, 3 }, + { {SyncPurpose_names + 163, 43}, 17 }, + { {SyncPurpose_names + 206, 33}, 6 }, + { {SyncPurpose_names + 239, 27}, 1 }, + { {SyncPurpose_names + 266, 30}, 4 }, + { {SyncPurpose_names + 296, 36}, 16 }, + { {SyncPurpose_names + 332, 47}, 13 }, + { {SyncPurpose_names + 379, 27}, 12 }, + { {SyncPurpose_names + 406, 34}, 10 }, + { {SyncPurpose_names + 440, 30}, 8 }, + { {SyncPurpose_names + 470, 30}, 7 }, + { {SyncPurpose_names + 500, 45}, 9 }, + { {SyncPurpose_names + 545, 20}, 0 }, + { {SyncPurpose_names + 565, 47}, 14 }, }; static const int SyncPurpose_entries_by_number[] = { - 16, // 0 -> SYNC_PURPOSE_UNKNOWN - 7, // 1 -> SYNC_PURPOSE_ON_DEMAND_SYNC - 2, // 2 -> SYNC_PURPOSE_CHIME_NOTIFICATION - 4, // 3 -> SYNC_PURPOSE_DAILY_SYNC - 8, // 4 -> SYNC_PURPOSE_OPT_IN_FIRST_SYNC - 1, // 5 -> SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN - 6, // 6 -> SYNC_PURPOSE_NEARBY_SHARE_ENABLED - 14, // 7 -> SYNC_PURPOSE_SYNC_AT_FAST_INIT - 13, // 8 -> SYNC_PURPOSE_SYNC_AT_DISCOVERY - 15, // 9 -> SYNC_PURPOSE_SYNC_AT_LOAD_PRIVATE_CERTIFICATE - 12, // 10 -> SYNC_PURPOSE_SYNC_AT_ADVERTISEMENT - 3, // 11 -> SYNC_PURPOSE_CONTACT_LIST_CHANGE - 11, // 12 -> SYNC_PURPOSE_SHOW_C11N_VIEW - 10, // 13 -> SYNC_PURPOSE_REGULAR_CHECK_CONTACT_REACHABILITY - 17, // 14 -> SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE - 0, // 15 -> SYNC_PURPOSE_ACCOUNT_CHANGE - 9, // 16 -> SYNC_PURPOSE_REGENERATE_CERTIFICATES - 5, // 17 -> SYNC_PURPOSE_DEVICE_CONTACTS_CONSENT_CHANGE + 17, // 0 -> SYNC_PURPOSE_UNKNOWN + 8, // 1 -> SYNC_PURPOSE_ON_DEMAND_SYNC + 3, // 2 -> SYNC_PURPOSE_CHIME_NOTIFICATION + 5, // 3 -> SYNC_PURPOSE_DAILY_SYNC + 9, // 4 -> SYNC_PURPOSE_OPT_IN_FIRST_SYNC + 2, // 5 -> SYNC_PURPOSE_CHECK_DEFAULT_OPT_IN + 7, // 6 -> SYNC_PURPOSE_NEARBY_SHARE_ENABLED + 15, // 7 -> SYNC_PURPOSE_SYNC_AT_FAST_INIT + 14, // 8 -> SYNC_PURPOSE_SYNC_AT_DISCOVERY + 16, // 9 -> SYNC_PURPOSE_SYNC_AT_LOAD_PRIVATE_CERTIFICATE + 13, // 10 -> SYNC_PURPOSE_SYNC_AT_ADVERTISEMENT + 4, // 11 -> SYNC_PURPOSE_CONTACT_LIST_CHANGE + 12, // 12 -> SYNC_PURPOSE_SHOW_C11N_VIEW + 11, // 13 -> SYNC_PURPOSE_REGULAR_CHECK_CONTACT_REACHABILITY + 18, // 14 -> SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE + 1, // 15 -> SYNC_PURPOSE_ACCOUNT_CHANGE + 10, // 16 -> SYNC_PURPOSE_REGENERATE_CERTIFICATES + 6, // 17 -> SYNC_PURPOSE_DEVICE_CONTACTS_CONSENT_CHANGE + 0, // 18 -> SYNC_EXHAUST_SALT }; const std::string& SyncPurpose_Name( @@ -1719,12 +1751,12 @@ const std::string& SyncPurpose_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( SyncPurpose_entries, SyncPurpose_entries_by_number, - 18, SyncPurpose_strings); + 19, SyncPurpose_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( SyncPurpose_entries, SyncPurpose_entries_by_number, - 18, value); + 19, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : SyncPurpose_strings[idx].get(); } @@ -1732,7 +1764,7 @@ bool SyncPurpose_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SyncPurpose* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - SyncPurpose_entries, 18, name, &int_value); + SyncPurpose_entries, 19, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -1918,19 +1950,21 @@ bool AdvertisingMode_IsValid(int value) { case 2: case 3: case 4: + case 5: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed AdvertisingMode_strings[5] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed AdvertisingMode_strings[6] = {}; static const char AdvertisingMode_names[] = "BACKGROUND_ADVERTISING_MODE" "FOREGROUND_ADVERTISING_MODE" "MIDGROUND_ADVERTISING_MODE" "SCREEN_OFF_ADVERTISING_MODE" + "SUSPENDED_ADVERTISING_MODE" "UNKNOWN_ADVERTISING_MODE"; static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AdvertisingMode_entries[] = { @@ -1938,15 +1972,17 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AdvertisingMode_entrie { {AdvertisingMode_names + 27, 27}, 4 }, { {AdvertisingMode_names + 54, 26}, 3 }, { {AdvertisingMode_names + 80, 27}, 1 }, - { {AdvertisingMode_names + 107, 24}, 0 }, + { {AdvertisingMode_names + 107, 26}, 5 }, + { {AdvertisingMode_names + 133, 24}, 0 }, }; static const int AdvertisingMode_entries_by_number[] = { - 4, // 0 -> UNKNOWN_ADVERTISING_MODE + 5, // 0 -> UNKNOWN_ADVERTISING_MODE 3, // 1 -> SCREEN_OFF_ADVERTISING_MODE 0, // 2 -> BACKGROUND_ADVERTISING_MODE 2, // 3 -> MIDGROUND_ADVERTISING_MODE 1, // 4 -> FOREGROUND_ADVERTISING_MODE + 4, // 5 -> SUSPENDED_ADVERTISING_MODE }; const std::string& AdvertisingMode_Name( @@ -1955,12 +1991,12 @@ const std::string& AdvertisingMode_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( AdvertisingMode_entries, AdvertisingMode_entries_by_number, - 5, AdvertisingMode_strings); + 6, AdvertisingMode_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( AdvertisingMode_entries, AdvertisingMode_entries_by_number, - 5, value); + 6, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : AdvertisingMode_strings[idx].get(); } @@ -1968,7 +2004,7 @@ bool AdvertisingMode_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AdvertisingMode* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - AdvertisingMode_entries, 5, name, &int_value); + AdvertisingMode_entries, 6, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -1981,19 +2017,21 @@ bool DiscoveryMode_IsValid(int value) { case 2: case 3: case 4: + case 5: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed DiscoveryMode_strings[5] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed DiscoveryMode_strings[6] = {}; static const char DiscoveryMode_names[] = "BACKGROUND_DISCOVERY_MODE" "FOREGROUND_DISCOVERY_MODE" "MIDGROUND_DISCOVERY_MODE" "SCREEN_OFF_DISCOVERY_MODE" + "SUSPENDED_DISCOVERY_MODE" "UNKNOWN_DISCOVERY_MODE"; static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DiscoveryMode_entries[] = { @@ -2001,15 +2039,17 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DiscoveryMode_entries[ { {DiscoveryMode_names + 25, 25}, 4 }, { {DiscoveryMode_names + 50, 24}, 3 }, { {DiscoveryMode_names + 74, 25}, 1 }, - { {DiscoveryMode_names + 99, 22}, 0 }, + { {DiscoveryMode_names + 99, 24}, 5 }, + { {DiscoveryMode_names + 123, 22}, 0 }, }; static const int DiscoveryMode_entries_by_number[] = { - 4, // 0 -> UNKNOWN_DISCOVERY_MODE + 5, // 0 -> UNKNOWN_DISCOVERY_MODE 3, // 1 -> SCREEN_OFF_DISCOVERY_MODE 0, // 2 -> BACKGROUND_DISCOVERY_MODE 2, // 3 -> MIDGROUND_DISCOVERY_MODE 1, // 4 -> FOREGROUND_DISCOVERY_MODE + 4, // 5 -> SUSPENDED_DISCOVERY_MODE }; const std::string& DiscoveryMode_Name( @@ -2018,12 +2058,12 @@ const std::string& DiscoveryMode_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( DiscoveryMode_entries, DiscoveryMode_entries_by_number, - 5, DiscoveryMode_strings); + 6, DiscoveryMode_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( DiscoveryMode_entries, DiscoveryMode_entries_by_number, - 5, value); + 6, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : DiscoveryMode_strings[idx].get(); } @@ -2031,7 +2071,7 @@ bool DiscoveryMode_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DiscoveryMode* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - DiscoveryMode_entries, 5, name, &int_value); + DiscoveryMode_entries, 6, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -3455,6 +3495,255 @@ bool ButtonStatus_Parse( } return success; } +bool CloudCreateSharingResult_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: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed CloudCreateSharingResult_strings[10] = {}; + +static const char CloudCreateSharingResult_names[] = + "CLOUD_CREATE_SHARING_RESULT_ALREADY_EXIST" + "CLOUD_CREATE_SHARING_RESULT_ALREADY_STARTED" + "CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_COUNT" + "CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_SIZE" + "CLOUD_CREATE_SHARING_RESULT_INVALID_ARGUMENT" + "CLOUD_CREATE_SHARING_RESULT_NETWORK_ERROR" + "CLOUD_CREATE_SHARING_RESULT_REMOTE_ERROR" + "CLOUD_CREATE_SHARING_RESULT_SIGN_IN_REQUIRE" + "CLOUD_CREATE_SHARING_RESULT_SUCCESS" + "CLOUD_CREATE_SHARING_RESULT_UNKNOWN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CloudCreateSharingResult_entries[] = { + { {CloudCreateSharingResult_names + 0, 41}, 3 }, + { {CloudCreateSharingResult_names + 41, 43}, 4 }, + { {CloudCreateSharingResult_names + 84, 51}, 8 }, + { {CloudCreateSharingResult_names + 135, 50}, 9 }, + { {CloudCreateSharingResult_names + 185, 44}, 6 }, + { {CloudCreateSharingResult_names + 229, 41}, 5 }, + { {CloudCreateSharingResult_names + 270, 40}, 7 }, + { {CloudCreateSharingResult_names + 310, 43}, 2 }, + { {CloudCreateSharingResult_names + 353, 35}, 1 }, + { {CloudCreateSharingResult_names + 388, 35}, 0 }, +}; + +static const int CloudCreateSharingResult_entries_by_number[] = { + 9, // 0 -> CLOUD_CREATE_SHARING_RESULT_UNKNOWN + 8, // 1 -> CLOUD_CREATE_SHARING_RESULT_SUCCESS + 7, // 2 -> CLOUD_CREATE_SHARING_RESULT_SIGN_IN_REQUIRE + 0, // 3 -> CLOUD_CREATE_SHARING_RESULT_ALREADY_EXIST + 1, // 4 -> CLOUD_CREATE_SHARING_RESULT_ALREADY_STARTED + 5, // 5 -> CLOUD_CREATE_SHARING_RESULT_NETWORK_ERROR + 4, // 6 -> CLOUD_CREATE_SHARING_RESULT_INVALID_ARGUMENT + 6, // 7 -> CLOUD_CREATE_SHARING_RESULT_REMOTE_ERROR + 2, // 8 -> CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_COUNT + 3, // 9 -> CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_SIZE +}; + +const std::string& CloudCreateSharingResult_Name( + CloudCreateSharingResult value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + CloudCreateSharingResult_entries, + CloudCreateSharingResult_entries_by_number, + 10, CloudCreateSharingResult_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + CloudCreateSharingResult_entries, + CloudCreateSharingResult_entries_by_number, + 10, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + CloudCreateSharingResult_strings[idx].get(); +} +bool CloudCreateSharingResult_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CloudCreateSharingResult* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + CloudCreateSharingResult_entries, 10, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool CloudRegisterReceiverResult_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: + case 12: + case 13: + case 14: + case 15: + case 16: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed CloudRegisterReceiverResult_strings[17] = {}; + +static const char CloudRegisterReceiverResult_names[] = + "CLOUD_REGISTER_RECEIVER_RESULT_ABORTED" + "CLOUD_REGISTER_RECEIVER_RESULT_ALREADY_EXISTS" + "CLOUD_REGISTER_RECEIVER_RESULT_CANCELLED" + "CLOUD_REGISTER_RECEIVER_RESULT_DATA_LOSS" + "CLOUD_REGISTER_RECEIVER_RESULT_DEADLINE_EXCEEDED" + "CLOUD_REGISTER_RECEIVER_RESULT_FAILED_PRECONDITION" + "CLOUD_REGISTER_RECEIVER_RESULT_INTERNAL" + "CLOUD_REGISTER_RECEIVER_RESULT_INVALID_ARGUMENT" + "CLOUD_REGISTER_RECEIVER_RESULT_NOT_FOUND" + "CLOUD_REGISTER_RECEIVER_RESULT_OUT_OF_RANGE" + "CLOUD_REGISTER_RECEIVER_RESULT_PERMISSION_DENIED" + "CLOUD_REGISTER_RECEIVER_RESULT_RESOURCE_EXHAUSTED" + "CLOUD_REGISTER_RECEIVER_RESULT_SUCCESS" + "CLOUD_REGISTER_RECEIVER_RESULT_UNAUTHENTICATED" + "CLOUD_REGISTER_RECEIVER_RESULT_UNAVAILABLE" + "CLOUD_REGISTER_RECEIVER_RESULT_UNIMPLEMENTED" + "CLOUD_REGISTER_RECEIVER_RESULT_UNKNOWN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CloudRegisterReceiverResult_entries[] = { + { {CloudRegisterReceiverResult_names + 0, 38}, 13 }, + { {CloudRegisterReceiverResult_names + 38, 45}, 9 }, + { {CloudRegisterReceiverResult_names + 83, 40}, 11 }, + { {CloudRegisterReceiverResult_names + 123, 40}, 16 }, + { {CloudRegisterReceiverResult_names + 163, 48}, 3 }, + { {CloudRegisterReceiverResult_names + 211, 50}, 12 }, + { {CloudRegisterReceiverResult_names + 261, 39}, 4 }, + { {CloudRegisterReceiverResult_names + 300, 47}, 2 }, + { {CloudRegisterReceiverResult_names + 347, 40}, 8 }, + { {CloudRegisterReceiverResult_names + 387, 43}, 14 }, + { {CloudRegisterReceiverResult_names + 430, 48}, 7 }, + { {CloudRegisterReceiverResult_names + 478, 49}, 5 }, + { {CloudRegisterReceiverResult_names + 527, 38}, 1 }, + { {CloudRegisterReceiverResult_names + 565, 46}, 10 }, + { {CloudRegisterReceiverResult_names + 611, 42}, 6 }, + { {CloudRegisterReceiverResult_names + 653, 44}, 15 }, + { {CloudRegisterReceiverResult_names + 697, 38}, 0 }, +}; + +static const int CloudRegisterReceiverResult_entries_by_number[] = { + 16, // 0 -> CLOUD_REGISTER_RECEIVER_RESULT_UNKNOWN + 12, // 1 -> CLOUD_REGISTER_RECEIVER_RESULT_SUCCESS + 7, // 2 -> CLOUD_REGISTER_RECEIVER_RESULT_INVALID_ARGUMENT + 4, // 3 -> CLOUD_REGISTER_RECEIVER_RESULT_DEADLINE_EXCEEDED + 6, // 4 -> CLOUD_REGISTER_RECEIVER_RESULT_INTERNAL + 11, // 5 -> CLOUD_REGISTER_RECEIVER_RESULT_RESOURCE_EXHAUSTED + 14, // 6 -> CLOUD_REGISTER_RECEIVER_RESULT_UNAVAILABLE + 10, // 7 -> CLOUD_REGISTER_RECEIVER_RESULT_PERMISSION_DENIED + 8, // 8 -> CLOUD_REGISTER_RECEIVER_RESULT_NOT_FOUND + 1, // 9 -> CLOUD_REGISTER_RECEIVER_RESULT_ALREADY_EXISTS + 13, // 10 -> CLOUD_REGISTER_RECEIVER_RESULT_UNAUTHENTICATED + 2, // 11 -> CLOUD_REGISTER_RECEIVER_RESULT_CANCELLED + 5, // 12 -> CLOUD_REGISTER_RECEIVER_RESULT_FAILED_PRECONDITION + 0, // 13 -> CLOUD_REGISTER_RECEIVER_RESULT_ABORTED + 9, // 14 -> CLOUD_REGISTER_RECEIVER_RESULT_OUT_OF_RANGE + 15, // 15 -> CLOUD_REGISTER_RECEIVER_RESULT_UNIMPLEMENTED + 3, // 16 -> CLOUD_REGISTER_RECEIVER_RESULT_DATA_LOSS +}; + +const std::string& CloudRegisterReceiverResult_Name( + CloudRegisterReceiverResult value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + CloudRegisterReceiverResult_entries, + CloudRegisterReceiverResult_entries_by_number, + 17, CloudRegisterReceiverResult_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + CloudRegisterReceiverResult_entries, + CloudRegisterReceiverResult_entries_by_number, + 17, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + CloudRegisterReceiverResult_strings[idx].get(); +} +bool CloudRegisterReceiverResult_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CloudRegisterReceiverResult* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + CloudRegisterReceiverResult_entries, 17, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool CloudActionType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed CloudActionType_strings[3] = {}; + +static const char CloudActionType_names[] = + "CLOUD_ACTION_TYPE_NORMAL" + "CLOUD_ACTION_TYPE_RETRY" + "CLOUD_ACTION_TYPE_UNKNOWN"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CloudActionType_entries[] = { + { {CloudActionType_names + 0, 24}, 1 }, + { {CloudActionType_names + 24, 23}, 2 }, + { {CloudActionType_names + 47, 25}, 0 }, +}; + +static const int CloudActionType_entries_by_number[] = { + 2, // 0 -> CLOUD_ACTION_TYPE_UNKNOWN + 0, // 1 -> CLOUD_ACTION_TYPE_NORMAL + 1, // 2 -> CLOUD_ACTION_TYPE_RETRY +}; + +const std::string& CloudActionType_Name( + CloudActionType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + CloudActionType_entries, + CloudActionType_entries_by_number, + 3, CloudActionType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + CloudActionType_entries, + CloudActionType_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + CloudActionType_strings[idx].get(); +} +bool CloudActionType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CloudActionType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + CloudActionType_entries, 3, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} // @@protoc_insertion_point(namespace_scope) } // namespace sharing diff --git a/compiled_proto/proto/sharing_enums.pb.h b/compiled_proto/proto/sharing_enums.pb.h index 4452d448..a46f205f 100644 --- a/compiled_proto/proto/sharing_enums.pb.h +++ b/compiled_proto/proto/sharing_enums.pb.h @@ -13,7 +13,7 @@ #error incompatible with your Protocol Buffer headers. Please update #error your headers. #endif -#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019005 < 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. @@ -131,11 +131,18 @@ enum EventType : int { START_QR_CODE_SESSION = 70, QR_CODE_OPENED_IN_WEB_CLIENT = 71, HATS_JOINT_EVENT = 72, - RECEIVE_PREVIEWS = 73 + RECEIVE_PREVIEWS = 73, + CLOUD_CREATE_SHARING_REQUEST = 74, + CLOUD_REGISTER_RECEIVER = 75, + CLOUD_UPLOAD_START = 76, + CLOUD_UPLOAD_END = 77, + CLOUD_DOWNLOAD_START = 78, + CLOUD_DOWNLOAD_END = 79, + CLOUD_SHARING_RPC_RESULT = 80 }; bool EventType_IsValid(int value); constexpr EventType EventType_MIN = UNKNOWN_EVENT_TYPE; -constexpr EventType EventType_MAX = RECEIVE_PREVIEWS; +constexpr EventType EventType_MAX = CLOUD_SHARING_RPC_RESULT; constexpr int EventType_ARRAYSIZE = EventType_MAX + 1; const std::string& EventType_Name(EventType value); @@ -581,11 +588,12 @@ enum SyncPurpose : int { SYNC_PURPOSE_VISIBILITY_SELECTED_CONTACT_CHANGE = 14, SYNC_PURPOSE_ACCOUNT_CHANGE = 15, SYNC_PURPOSE_REGENERATE_CERTIFICATES = 16, - SYNC_PURPOSE_DEVICE_CONTACTS_CONSENT_CHANGE = 17 + SYNC_PURPOSE_DEVICE_CONTACTS_CONSENT_CHANGE = 17, + SYNC_EXHAUST_SALT = 18 }; bool SyncPurpose_IsValid(int value); constexpr SyncPurpose SyncPurpose_MIN = SYNC_PURPOSE_UNKNOWN; -constexpr SyncPurpose SyncPurpose_MAX = SYNC_PURPOSE_DEVICE_CONTACTS_CONSENT_CHANGE; +constexpr SyncPurpose SyncPurpose_MAX = SYNC_EXHAUST_SALT; constexpr int SyncPurpose_ARRAYSIZE = SyncPurpose_MAX + 1; const std::string& SyncPurpose_Name(SyncPurpose value); @@ -621,7 +629,7 @@ bool ClientRole_Parse( enum ScanType : int { UNKNOWN_SCAN_TYPE = 0, FOREGROUND_SCAN = 1, - FOREGROUND_RETRY_SCAN = 2, + FOREGROUND_RETRY_SCAN PROTOBUF_DEPRECATED_ENUM = 2, DIRECT_SHARE_SCAN = 3, BACKGROUND_SCAN = 4 }; @@ -665,11 +673,12 @@ enum AdvertisingMode : int { SCREEN_OFF_ADVERTISING_MODE = 1, BACKGROUND_ADVERTISING_MODE = 2, MIDGROUND_ADVERTISING_MODE = 3, - FOREGROUND_ADVERTISING_MODE = 4 + FOREGROUND_ADVERTISING_MODE = 4, + SUSPENDED_ADVERTISING_MODE = 5 }; bool AdvertisingMode_IsValid(int value); constexpr AdvertisingMode AdvertisingMode_MIN = UNKNOWN_ADVERTISING_MODE; -constexpr AdvertisingMode AdvertisingMode_MAX = FOREGROUND_ADVERTISING_MODE; +constexpr AdvertisingMode AdvertisingMode_MAX = SUSPENDED_ADVERTISING_MODE; constexpr int AdvertisingMode_ARRAYSIZE = AdvertisingMode_MAX + 1; const std::string& AdvertisingMode_Name(AdvertisingMode value); @@ -687,11 +696,12 @@ enum DiscoveryMode : int { SCREEN_OFF_DISCOVERY_MODE = 1, BACKGROUND_DISCOVERY_MODE = 2, MIDGROUND_DISCOVERY_MODE = 3, - FOREGROUND_DISCOVERY_MODE = 4 + FOREGROUND_DISCOVERY_MODE = 4, + SUSPENDED_DISCOVERY_MODE = 5 }; bool DiscoveryMode_IsValid(int value); constexpr DiscoveryMode DiscoveryMode_MIN = UNKNOWN_DISCOVERY_MODE; -constexpr DiscoveryMode DiscoveryMode_MAX = FOREGROUND_DISCOVERY_MODE; +constexpr DiscoveryMode DiscoveryMode_MAX = SUSPENDED_DISCOVERY_MODE; constexpr int DiscoveryMode_ARRAYSIZE = DiscoveryMode_MAX + 1; const std::string& DiscoveryMode_Name(DiscoveryMode value); @@ -1196,6 +1206,87 @@ inline const std::string& ButtonStatus_Name(T enum_t_value) { } bool ButtonStatus_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ButtonStatus* value); +enum CloudCreateSharingResult : int { + CLOUD_CREATE_SHARING_RESULT_UNKNOWN = 0, + CLOUD_CREATE_SHARING_RESULT_SUCCESS = 1, + CLOUD_CREATE_SHARING_RESULT_SIGN_IN_REQUIRE = 2, + CLOUD_CREATE_SHARING_RESULT_ALREADY_EXIST = 3, + CLOUD_CREATE_SHARING_RESULT_ALREADY_STARTED = 4, + CLOUD_CREATE_SHARING_RESULT_NETWORK_ERROR = 5, + CLOUD_CREATE_SHARING_RESULT_INVALID_ARGUMENT = 6, + CLOUD_CREATE_SHARING_RESULT_REMOTE_ERROR = 7, + CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_COUNT = 8, + CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_SIZE = 9 +}; +bool CloudCreateSharingResult_IsValid(int value); +constexpr CloudCreateSharingResult CloudCreateSharingResult_MIN = CLOUD_CREATE_SHARING_RESULT_UNKNOWN; +constexpr CloudCreateSharingResult CloudCreateSharingResult_MAX = CLOUD_CREATE_SHARING_RESULT_FILE_LIMIT_EXCEED_SIZE; +constexpr int CloudCreateSharingResult_ARRAYSIZE = CloudCreateSharingResult_MAX + 1; + +const std::string& CloudCreateSharingResult_Name(CloudCreateSharingResult value); +template +inline const std::string& CloudCreateSharingResult_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CloudCreateSharingResult_Name."); + return CloudCreateSharingResult_Name(static_cast(enum_t_value)); +} +bool CloudCreateSharingResult_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CloudCreateSharingResult* value); +enum CloudRegisterReceiverResult : int { + CLOUD_REGISTER_RECEIVER_RESULT_UNKNOWN = 0, + CLOUD_REGISTER_RECEIVER_RESULT_SUCCESS = 1, + CLOUD_REGISTER_RECEIVER_RESULT_INVALID_ARGUMENT = 2, + CLOUD_REGISTER_RECEIVER_RESULT_DEADLINE_EXCEEDED = 3, + CLOUD_REGISTER_RECEIVER_RESULT_INTERNAL = 4, + CLOUD_REGISTER_RECEIVER_RESULT_RESOURCE_EXHAUSTED = 5, + CLOUD_REGISTER_RECEIVER_RESULT_UNAVAILABLE = 6, + CLOUD_REGISTER_RECEIVER_RESULT_PERMISSION_DENIED = 7, + CLOUD_REGISTER_RECEIVER_RESULT_NOT_FOUND = 8, + CLOUD_REGISTER_RECEIVER_RESULT_ALREADY_EXISTS = 9, + CLOUD_REGISTER_RECEIVER_RESULT_UNAUTHENTICATED = 10, + CLOUD_REGISTER_RECEIVER_RESULT_CANCELLED = 11, + CLOUD_REGISTER_RECEIVER_RESULT_FAILED_PRECONDITION = 12, + CLOUD_REGISTER_RECEIVER_RESULT_ABORTED = 13, + CLOUD_REGISTER_RECEIVER_RESULT_OUT_OF_RANGE = 14, + CLOUD_REGISTER_RECEIVER_RESULT_UNIMPLEMENTED = 15, + CLOUD_REGISTER_RECEIVER_RESULT_DATA_LOSS = 16 +}; +bool CloudRegisterReceiverResult_IsValid(int value); +constexpr CloudRegisterReceiverResult CloudRegisterReceiverResult_MIN = CLOUD_REGISTER_RECEIVER_RESULT_UNKNOWN; +constexpr CloudRegisterReceiverResult CloudRegisterReceiverResult_MAX = CLOUD_REGISTER_RECEIVER_RESULT_DATA_LOSS; +constexpr int CloudRegisterReceiverResult_ARRAYSIZE = CloudRegisterReceiverResult_MAX + 1; + +const std::string& CloudRegisterReceiverResult_Name(CloudRegisterReceiverResult value); +template +inline const std::string& CloudRegisterReceiverResult_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CloudRegisterReceiverResult_Name."); + return CloudRegisterReceiverResult_Name(static_cast(enum_t_value)); +} +bool CloudRegisterReceiverResult_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CloudRegisterReceiverResult* value); +enum CloudActionType : int { + CLOUD_ACTION_TYPE_UNKNOWN = 0, + CLOUD_ACTION_TYPE_NORMAL = 1, + CLOUD_ACTION_TYPE_RETRY = 2 +}; +bool CloudActionType_IsValid(int value); +constexpr CloudActionType CloudActionType_MIN = CLOUD_ACTION_TYPE_UNKNOWN; +constexpr CloudActionType CloudActionType_MAX = CLOUD_ACTION_TYPE_RETRY; +constexpr int CloudActionType_ARRAYSIZE = CloudActionType_MAX + 1; + +const std::string& CloudActionType_Name(CloudActionType value); +template +inline const std::string& CloudActionType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function CloudActionType_Name."); + return CloudActionType_Name(static_cast(enum_t_value)); +} +bool CloudActionType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CloudActionType* value); // =================================================================== @@ -1266,6 +1357,9 @@ template <> struct is_proto_enum< ::location::nearby::proto::sharing::DecryptCer template <> struct is_proto_enum< ::location::nearby::proto::sharing::ContactAccess> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::IdentityVerification> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::proto::sharing::ButtonStatus> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::CloudCreateSharingResult> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::CloudRegisterReceiverResult> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::proto::sharing::CloudActionType> : ::std::true_type {}; PROTOBUF_NAMESPACE_CLOSE diff --git a/compiled_proto/sharing/proto/analytics/nearby_sharing_log.pb.cc b/compiled_proto/sharing/proto/analytics/nearby_sharing_log.pb.cc index 4f215ffe..8d7986ed 100644 --- a/compiled_proto/sharing/proto/analytics/nearby_sharing_log.pb.cc +++ b/compiled_proto/sharing/proto/analytics/nearby_sharing_log.pb.cc @@ -41,7 +41,14 @@ constexpr SharingLog_DeviceSettings::SharingLog_DeviceSettings( , is_show_notification_enabled_(false) , is_bt_enabled_(false) , is_location_enabled_(false) - , is_wifi_enabled_(false){} + , is_wifi_enabled_(false) + , first_successful_transfer_date_(0) + , previous_successful_transfer_date_(0) + , lifetime_transfer_count_(0) + , contact_access_(0) + + , identity_verification_(0) +{} struct SharingLog_DeviceSettingsDefaultTypeInternal { constexpr SharingLog_DeviceSettingsDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -85,6 +92,7 @@ constexpr SharingLog_EstablishConnection::SharingLog_EstablishConnection( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : referrer_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , share_target_info_(nullptr) + , qr_code_receiver_connect_latency_(nullptr) , session_id_(int64_t{0}) , status_(0) @@ -192,7 +200,8 @@ constexpr SharingLog_ScanForShareTargetsStart::SharingLog_ScanForShareTargetsSta , scan_type_(0) - , flow_id_(int64_t{0}){} + , flow_id_(int64_t{0}) + , use_qr_code_(false){} struct SharingLog_ScanForShareTargetsStartDefaultTypeInternal { constexpr SharingLog_ScanForShareTargetsStartDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -298,7 +307,11 @@ struct SharingLog_AutoDismissFastInitializationDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_AutoDismissFastInitializationDefaultTypeInternal _SharingLog_AutoDismissFastInitialization_default_instance_; constexpr SharingLog_EventMetadata::SharingLog_EventMetadata( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : use_case_(0) + : cloud_sharing_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , cloud_receiver_session_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , external_provider_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , external_provider_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , use_case_(0) , initial_opt_in_(false) , opt_in_(false) @@ -318,6 +331,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_EventMetadataDefault constexpr SharingLog_DiscoverShareTarget::SharingLog_DiscoverShareTarget( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : referrer_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , cloud_receiver_session_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , share_target_info_(nullptr) , duration_since_scanning_(nullptr) , session_id_(int64_t{0}) @@ -360,7 +374,8 @@ struct SharingLog_ParsingFailedEndpointIdDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_ParsingFailedEndpointIdDefaultTypeInternal _SharingLog_ParsingFailedEndpointId_default_instance_; constexpr SharingLog_DescribeAttachments::SharingLog_DescribeAttachments( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : attachments_info_(nullptr){} + : attachments_info_(nullptr) + , download_duration_(nullptr){} struct SharingLog_DescribeAttachmentsDefaultTypeInternal { constexpr SharingLog_DescribeAttachmentsDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -417,10 +432,13 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_RespondToIntroductio constexpr SharingLog_SendAttachmentsStart::SharingLog_SendAttachmentsStart( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : attachments_info_(nullptr) + , share_target_info_(nullptr) , session_id_(int64_t{0}) , transfer_position_(0) , concurrent_connections_(0) - , qr_code_flow_(false){} + , qr_code_flow_(false) + , advanced_protection_enabled_(false) + , advanced_protection_mismatch_(false){} struct SharingLog_SendAttachmentsStartDefaultTypeInternal { constexpr SharingLog_SendAttachmentsStartDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -443,7 +461,14 @@ constexpr SharingLog_SendAttachmentsEnd::SharingLog_SendAttachmentsEnd( , duration_millis_(int64_t{0}) , concurrent_connections_(0) , connection_layer_status_(0) -{} + + , first_successful_transfer_date_(0) + , previous_successful_transfer_date_(0) + , lifetime_transfer_count_(0) + , connection_medium_(0) + , data_usage_(0) + + , is_mutual_contact_(false){} struct SharingLog_SendAttachmentsEndDefaultTypeInternal { constexpr SharingLog_SendAttachmentsEndDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -474,6 +499,12 @@ constexpr SharingLog_ReceiveAttachmentsEnd::SharingLog_ReceiveAttachmentsEnd( , session_id_(int64_t{0}) , received_bytes_(int64_t{0}) , status_(0) + + , first_successful_transfer_date_(0) + , previous_successful_transfer_date_(0) + , lifetime_transfer_count_(0) + , connection_medium_(0) + , data_usage_(0) {} struct SharingLog_ReceiveAttachmentsEndDefaultTypeInternal { constexpr SharingLog_ReceiveAttachmentsEndDefaultTypeInternal() @@ -944,7 +975,9 @@ constexpr SharingLog_ShareTargetInfo::SharingLog_ShareTargetInfo( , os_type_(0) , device_relationship_(0) -{} + + , has_matching_qr_code_(false) + , is_external_(false){} struct SharingLog_ShareTargetInfoDefaultTypeInternal { constexpr SharingLog_ShareTargetInfoDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -1052,6 +1085,22 @@ struct SharingLog_StreamAttachmentDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_StreamAttachmentDefaultTypeInternal _SharingLog_StreamAttachment_default_instance_; +constexpr SharingLog_CloudAttachmentInfo::SharingLog_CloudAttachmentInfo( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : status_(0) + + , transferred_bytes_(int64_t{0}) + , duration_millis_(int64_t{0}) + , _oneof_case_{}{} +struct SharingLog_CloudAttachmentInfoDefaultTypeInternal { + constexpr SharingLog_CloudAttachmentInfoDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_CloudAttachmentInfoDefaultTypeInternal() {} + union { + SharingLog_CloudAttachmentInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_CloudAttachmentInfoDefaultTypeInternal _SharingLog_CloudAttachmentInfo_default_instance_; constexpr SharingLog_AppCrash::SharingLog_AppCrash( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : crash_reason_(0) @@ -1068,6 +1117,8 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_AppCrashDefaultTypeI constexpr SharingLog_SetupWizard::SharingLog_SetupWizard( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : visibility_(0) + + , previous_visibility_(0) {} struct SharingLog_SetupWizardDefaultTypeInternal { constexpr SharingLog_SetupWizardDefaultTypeInternal() @@ -1104,6 +1155,202 @@ struct SharingLog_SendDesktopTransferEventDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_SendDesktopTransferEventDefaultTypeInternal _SharingLog_SendDesktopTransferEvent_default_instance_; +constexpr SharingLog_ShowWaitingForAccept::SharingLog_ShowWaitingForAccept( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : button_status_(0) +{} +struct SharingLog_ShowWaitingForAcceptDefaultTypeInternal { + constexpr SharingLog_ShowWaitingForAcceptDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_ShowWaitingForAcceptDefaultTypeInternal() {} + union { + SharingLog_ShowWaitingForAccept _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_ShowWaitingForAcceptDefaultTypeInternal _SharingLog_ShowWaitingForAccept_default_instance_; +constexpr SharingLog_HighQualityMediumSetup::SharingLog_HighQualityMediumSetup( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : share_target_info_(nullptr) + , session_id_(int64_t{0}) + , duration_millis_(int64_t{0}) + , is_timeout_(false) + , original_quality_(0) + , connection_medium_(0) + , connection_mode_(0) + , instant_connection_result_(0){} +struct SharingLog_HighQualityMediumSetupDefaultTypeInternal { + constexpr SharingLog_HighQualityMediumSetupDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_HighQualityMediumSetupDefaultTypeInternal() {} + union { + SharingLog_HighQualityMediumSetup _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_HighQualityMediumSetupDefaultTypeInternal _SharingLog_HighQualityMediumSetup_default_instance_; +constexpr SharingLog_RpcCallStatus::SharingLog_RpcCallStatus( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : rpc_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , direction_(0) + + , error_code_(0) + , latency_millis_(int64_t{0}){} +struct SharingLog_RpcCallStatusDefaultTypeInternal { + constexpr SharingLog_RpcCallStatusDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_RpcCallStatusDefaultTypeInternal() {} + union { + SharingLog_RpcCallStatus _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_RpcCallStatusDefaultTypeInternal _SharingLog_RpcCallStatus_default_instance_; +constexpr SharingLog_StartQrCodeSession::SharingLog_StartQrCodeSession( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct SharingLog_StartQrCodeSessionDefaultTypeInternal { + constexpr SharingLog_StartQrCodeSessionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_StartQrCodeSessionDefaultTypeInternal() {} + union { + SharingLog_StartQrCodeSession _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_StartQrCodeSessionDefaultTypeInternal _SharingLog_StartQrCodeSession_default_instance_; +constexpr SharingLog_QrCodeOpenedInWebClient::SharingLog_QrCodeOpenedInWebClient( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : client_platform_(0) + + , is_retry_(false){} +struct SharingLog_QrCodeOpenedInWebClientDefaultTypeInternal { + constexpr SharingLog_QrCodeOpenedInWebClientDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_QrCodeOpenedInWebClientDefaultTypeInternal() {} + union { + SharingLog_QrCodeOpenedInWebClient _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_QrCodeOpenedInWebClientDefaultTypeInternal _SharingLog_QrCodeOpenedInWebClient_default_instance_; +constexpr SharingLog_HatsJointEvent::SharingLog_HatsJointEvent( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : hats_session_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , flow_id_(int64_t{0}){} +struct SharingLog_HatsJointEventDefaultTypeInternal { + constexpr SharingLog_HatsJointEventDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_HatsJointEventDefaultTypeInternal() {} + union { + SharingLog_HatsJointEvent _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_HatsJointEventDefaultTypeInternal _SharingLog_HatsJointEvent_default_instance_; +constexpr SharingLog_ReceivePreviews::SharingLog_ReceivePreviews( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : num_previews_(0){} +struct SharingLog_ReceivePreviewsDefaultTypeInternal { + constexpr SharingLog_ReceivePreviewsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_ReceivePreviewsDefaultTypeInternal() {} + union { + SharingLog_ReceivePreviews _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_ReceivePreviewsDefaultTypeInternal _SharingLog_ReceivePreviews_default_instance_; +constexpr SharingLog_CloudCreateSharingRequest::SharingLog_CloudCreateSharingRequest( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : attachments_info_(nullptr) + , result_(0) +{} +struct SharingLog_CloudCreateSharingRequestDefaultTypeInternal { + constexpr SharingLog_CloudCreateSharingRequestDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_CloudCreateSharingRequestDefaultTypeInternal() {} + union { + SharingLog_CloudCreateSharingRequest _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_CloudCreateSharingRequestDefaultTypeInternal _SharingLog_CloudCreateSharingRequest_default_instance_; +constexpr SharingLog_CloudRegisterReceiver::SharingLog_CloudRegisterReceiver( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : result_(0) +{} +struct SharingLog_CloudRegisterReceiverDefaultTypeInternal { + constexpr SharingLog_CloudRegisterReceiverDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_CloudRegisterReceiverDefaultTypeInternal() {} + union { + SharingLog_CloudRegisterReceiver _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_CloudRegisterReceiverDefaultTypeInternal _SharingLog_CloudRegisterReceiver_default_instance_; +constexpr SharingLog_CloudUploadStart::SharingLog_CloudUploadStart( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : attachments_info_(nullptr) + , action_type_(0) +{} +struct SharingLog_CloudUploadStartDefaultTypeInternal { + constexpr SharingLog_CloudUploadStartDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_CloudUploadStartDefaultTypeInternal() {} + union { + SharingLog_CloudUploadStart _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_CloudUploadStartDefaultTypeInternal _SharingLog_CloudUploadStart_default_instance_; +constexpr SharingLog_CloudUploadEnd::SharingLog_CloudUploadEnd( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : upload_infos_() + , action_type_(0) +{} +struct SharingLog_CloudUploadEndDefaultTypeInternal { + constexpr SharingLog_CloudUploadEndDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_CloudUploadEndDefaultTypeInternal() {} + union { + SharingLog_CloudUploadEnd _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_CloudUploadEndDefaultTypeInternal _SharingLog_CloudUploadEnd_default_instance_; +constexpr SharingLog_CloudDownloadStart::SharingLog_CloudDownloadStart( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : attachments_info_(nullptr) + , action_type_(0) +{} +struct SharingLog_CloudDownloadStartDefaultTypeInternal { + constexpr SharingLog_CloudDownloadStartDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_CloudDownloadStartDefaultTypeInternal() {} + union { + SharingLog_CloudDownloadStart _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_CloudDownloadStartDefaultTypeInternal _SharingLog_CloudDownloadStart_default_instance_; +constexpr SharingLog_CloudDownloadEnd::SharingLog_CloudDownloadEnd( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : download_infos_() + , action_type_(0) +{} +struct SharingLog_CloudDownloadEndDefaultTypeInternal { + constexpr SharingLog_CloudDownloadEndDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_CloudDownloadEndDefaultTypeInternal() {} + union { + SharingLog_CloudDownloadEnd _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_CloudDownloadEndDefaultTypeInternal _SharingLog_CloudDownloadEnd_default_instance_; +constexpr SharingLog_CloudSharingRpcResult::SharingLog_CloudSharingRpcResult( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : rpc_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , cloud_sharing_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , latency_millis_(int64_t{0}) + , status_code_(0){} +struct SharingLog_CloudSharingRpcResultDefaultTypeInternal { + constexpr SharingLog_CloudSharingRpcResultDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SharingLog_CloudSharingRpcResultDefaultTypeInternal() {} + union { + SharingLog_CloudSharingRpcResult _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SharingLog_CloudSharingRpcResultDefaultTypeInternal _SharingLog_CloudSharingRpcResult_default_instance_; constexpr SharingLog::SharingLog( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : version_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) @@ -1177,6 +1424,20 @@ constexpr SharingLog::SharingLog( , set_account_(nullptr) , decrypt_certificate_failure_(nullptr) , show_allow_permission_auto_access_(nullptr) + , show_waiting_for_accept_(nullptr) + , high_quality_medium_setup_(nullptr) + , rpc_call_status_(nullptr) + , start_qr_code_session_(nullptr) + , qr_code_opened_in_web_client_(nullptr) + , hats_joint_event_(nullptr) + , receive_previews_(nullptr) + , cloud_create_sharing_request_(nullptr) + , cloud_register_receiver_(nullptr) + , cloud_upload_start_(nullptr) + , cloud_upload_end_(nullptr) + , cloud_download_start_(nullptr) + , cloud_download_end_(nullptr) + , cloud_sharing_rpc_result_(nullptr) , event_type_(0) , log_source_(0) @@ -1276,17 +1537,19 @@ bool SharingLog_FileAttachment_Type_IsValid(int value) { case 3: case 4: case 5: + case 6: return true; default: return false; } } -static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed SharingLog_FileAttachment_Type_strings[6] = {}; +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed SharingLog_FileAttachment_Type_strings[7] = {}; static const char SharingLog_FileAttachment_Type_names[] = "ANDROID_APP" "AUDIO" + "CONTACT_CARD" "DOCUMENT" "IMAGE" "UNKNOWN_FILE_TYPE" @@ -1295,19 +1558,21 @@ static const char SharingLog_FileAttachment_Type_names[] = static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SharingLog_FileAttachment_Type_entries[] = { { {SharingLog_FileAttachment_Type_names + 0, 11}, 3 }, { {SharingLog_FileAttachment_Type_names + 11, 5}, 4 }, - { {SharingLog_FileAttachment_Type_names + 16, 8}, 5 }, - { {SharingLog_FileAttachment_Type_names + 24, 5}, 1 }, - { {SharingLog_FileAttachment_Type_names + 29, 17}, 0 }, - { {SharingLog_FileAttachment_Type_names + 46, 5}, 2 }, + { {SharingLog_FileAttachment_Type_names + 16, 12}, 6 }, + { {SharingLog_FileAttachment_Type_names + 28, 8}, 5 }, + { {SharingLog_FileAttachment_Type_names + 36, 5}, 1 }, + { {SharingLog_FileAttachment_Type_names + 41, 17}, 0 }, + { {SharingLog_FileAttachment_Type_names + 58, 5}, 2 }, }; static const int SharingLog_FileAttachment_Type_entries_by_number[] = { - 4, // 0 -> UNKNOWN_FILE_TYPE - 3, // 1 -> IMAGE - 5, // 2 -> VIDEO + 5, // 0 -> UNKNOWN_FILE_TYPE + 4, // 1 -> IMAGE + 6, // 2 -> VIDEO 0, // 3 -> ANDROID_APP 1, // 4 -> AUDIO - 2, // 5 -> DOCUMENT + 3, // 5 -> DOCUMENT + 2, // 6 -> CONTACT_CARD }; const std::string& SharingLog_FileAttachment_Type_Name( @@ -1316,12 +1581,12 @@ const std::string& SharingLog_FileAttachment_Type_Name( ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( SharingLog_FileAttachment_Type_entries, SharingLog_FileAttachment_Type_entries_by_number, - 6, SharingLog_FileAttachment_Type_strings); + 7, SharingLog_FileAttachment_Type_strings); (void) dummy; int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( SharingLog_FileAttachment_Type_entries, SharingLog_FileAttachment_Type_entries_by_number, - 6, value); + 7, value); return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : SharingLog_FileAttachment_Type_strings[idx].get(); } @@ -1329,7 +1594,7 @@ bool SharingLog_FileAttachment_Type_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SharingLog_FileAttachment_Type* value) { int int_value; bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( - SharingLog_FileAttachment_Type_entries, 6, name, &int_value); + SharingLog_FileAttachment_Type_entries, 7, name, &int_value); if (success) { *value = static_cast(int_value); } @@ -1342,10 +1607,152 @@ constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment::VIDEO; constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment::ANDROID_APP; constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment::AUDIO; constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment::DOCUMENT; +constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment::CONTACT_CARD; constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment::Type_MIN; constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment::Type_MAX; constexpr int SharingLog_FileAttachment::Type_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool SharingLog_RpcCallStatus_RpcDirection_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed SharingLog_RpcCallStatus_RpcDirection_strings[3] = {}; + +static const char SharingLog_RpcCallStatus_RpcDirection_names[] = + "INCOMING" + "OUTGOING" + "UNKNOWN_RPC_DIRECTION"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SharingLog_RpcCallStatus_RpcDirection_entries[] = { + { {SharingLog_RpcCallStatus_RpcDirection_names + 0, 8}, 1 }, + { {SharingLog_RpcCallStatus_RpcDirection_names + 8, 8}, 2 }, + { {SharingLog_RpcCallStatus_RpcDirection_names + 16, 21}, 0 }, +}; + +static const int SharingLog_RpcCallStatus_RpcDirection_entries_by_number[] = { + 2, // 0 -> UNKNOWN_RPC_DIRECTION + 0, // 1 -> INCOMING + 1, // 2 -> OUTGOING +}; + +const std::string& SharingLog_RpcCallStatus_RpcDirection_Name( + SharingLog_RpcCallStatus_RpcDirection value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + SharingLog_RpcCallStatus_RpcDirection_entries, + SharingLog_RpcCallStatus_RpcDirection_entries_by_number, + 3, SharingLog_RpcCallStatus_RpcDirection_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + SharingLog_RpcCallStatus_RpcDirection_entries, + SharingLog_RpcCallStatus_RpcDirection_entries_by_number, + 3, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + SharingLog_RpcCallStatus_RpcDirection_strings[idx].get(); +} +bool SharingLog_RpcCallStatus_RpcDirection_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SharingLog_RpcCallStatus_RpcDirection* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + SharingLog_RpcCallStatus_RpcDirection_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 SharingLog_RpcCallStatus_RpcDirection SharingLog_RpcCallStatus::UNKNOWN_RPC_DIRECTION; +constexpr SharingLog_RpcCallStatus_RpcDirection SharingLog_RpcCallStatus::INCOMING; +constexpr SharingLog_RpcCallStatus_RpcDirection SharingLog_RpcCallStatus::OUTGOING; +constexpr SharingLog_RpcCallStatus_RpcDirection SharingLog_RpcCallStatus::RpcDirection_MIN; +constexpr SharingLog_RpcCallStatus_RpcDirection SharingLog_RpcCallStatus::RpcDirection_MAX; +constexpr int SharingLog_RpcCallStatus::RpcDirection_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool SharingLog_QrCodeOpenedInWebClient_ClientPlatform_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed SharingLog_QrCodeOpenedInWebClient_ClientPlatform_strings[6] = {}; + +static const char SharingLog_QrCodeOpenedInWebClient_ClientPlatform_names[] = + "ANDROID" + "CHROME_OS" + "GENERIC" + "IOS" + "UNKNOWN_CLIENT_PLATFORM" + "WINDOWS"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry SharingLog_QrCodeOpenedInWebClient_ClientPlatform_entries[] = { + { {SharingLog_QrCodeOpenedInWebClient_ClientPlatform_names + 0, 7}, 2 }, + { {SharingLog_QrCodeOpenedInWebClient_ClientPlatform_names + 7, 9}, 4 }, + { {SharingLog_QrCodeOpenedInWebClient_ClientPlatform_names + 16, 7}, 1 }, + { {SharingLog_QrCodeOpenedInWebClient_ClientPlatform_names + 23, 3}, 3 }, + { {SharingLog_QrCodeOpenedInWebClient_ClientPlatform_names + 26, 23}, 0 }, + { {SharingLog_QrCodeOpenedInWebClient_ClientPlatform_names + 49, 7}, 5 }, +}; + +static const int SharingLog_QrCodeOpenedInWebClient_ClientPlatform_entries_by_number[] = { + 4, // 0 -> UNKNOWN_CLIENT_PLATFORM + 2, // 1 -> GENERIC + 0, // 2 -> ANDROID + 3, // 3 -> IOS + 1, // 4 -> CHROME_OS + 5, // 5 -> WINDOWS +}; + +const std::string& SharingLog_QrCodeOpenedInWebClient_ClientPlatform_Name( + SharingLog_QrCodeOpenedInWebClient_ClientPlatform value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_entries, + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_entries_by_number, + 6, SharingLog_QrCodeOpenedInWebClient_ClientPlatform_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_entries, + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_entries_by_number, + 6, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_strings[idx].get(); +} +bool SharingLog_QrCodeOpenedInWebClient_ClientPlatform_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SharingLog_QrCodeOpenedInWebClient_ClientPlatform* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_entries, 6, 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 SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::UNKNOWN_CLIENT_PLATFORM; +constexpr SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::GENERIC; +constexpr SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::ANDROID; +constexpr SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::IOS; +constexpr SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::CHROME_OS; +constexpr SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::WINDOWS; +constexpr SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::ClientPlatform_MIN; +constexpr SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::ClientPlatform_MAX; +constexpr int SharingLog_QrCodeOpenedInWebClient::ClientPlatform_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) // =================================================================== @@ -1687,6 +2094,21 @@ class SharingLog_DeviceSettings::_Internal { static void set_has_is_wifi_enabled(HasBits* has_bits) { (*has_bits)[0] |= 64u; } + static void set_has_first_successful_transfer_date(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_previous_successful_transfer_date(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_lifetime_transfer_count(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_contact_access(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_identity_verification(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } }; SharingLog_DeviceSettings::SharingLog_DeviceSettings(::PROTOBUF_NAMESPACE_ID::Arena* arena, @@ -1703,16 +2125,16 @@ SharingLog_DeviceSettings::SharingLog_DeviceSettings(const SharingLog_DeviceSett _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom(from._internal_metadata_); ::memcpy(&visibility_, &from.visibility_, - static_cast(reinterpret_cast(&is_wifi_enabled_) - - reinterpret_cast(&visibility_)) + sizeof(is_wifi_enabled_)); + static_cast(reinterpret_cast(&identity_verification_) - + reinterpret_cast(&visibility_)) + sizeof(identity_verification_)); // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.DeviceSettings) } inline void SharingLog_DeviceSettings::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&visibility_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&is_wifi_enabled_) - - reinterpret_cast(&visibility_)) + sizeof(is_wifi_enabled_)); + 0, static_cast(reinterpret_cast(&identity_verification_) - + reinterpret_cast(&visibility_)) + sizeof(identity_verification_)); } SharingLog_DeviceSettings::~SharingLog_DeviceSettings() { @@ -1743,10 +2165,15 @@ void SharingLog_DeviceSettings::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x000000ffu) { ::memset(&visibility_, 0, static_cast( - reinterpret_cast(&is_wifi_enabled_) - - reinterpret_cast(&visibility_)) + sizeof(is_wifi_enabled_)); + reinterpret_cast(&first_successful_transfer_date_) - + reinterpret_cast(&visibility_)) + sizeof(first_successful_transfer_date_)); + } + if (cached_has_bits & 0x00000f00u) { + ::memset(&previous_successful_transfer_date_, 0, static_cast( + reinterpret_cast(&identity_verification_) - + reinterpret_cast(&previous_successful_transfer_date_)) + sizeof(identity_verification_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -1830,6 +2257,59 @@ const char* SharingLog_DeviceSettings::_InternalParse(const char* ptr, ::PROTOBU } else goto handle_unusual; continue; + // optional int32 first_successful_transfer_date = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_first_successful_transfer_date(&has_bits); + first_successful_transfer_date_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 previous_successful_transfer_date = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 72)) { + _Internal::set_has_previous_successful_transfer_date(&has_bits); + previous_successful_transfer_date_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 lifetime_transfer_count = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 80)) { + _Internal::set_has_lifetime_transfer_count(&has_bits); + lifetime_transfer_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.proto.sharing.ContactAccess contact_access = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::sharing::ContactAccess_IsValid(val))) { + _internal_set_contact_access(static_cast<::location::nearby::proto::sharing::ContactAccess>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional .location.nearby.proto.sharing.IdentityVerification identity_verification = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::sharing::IdentityVerification_IsValid(val))) { + _internal_set_identity_verification(static_cast<::location::nearby::proto::sharing::IdentityVerification>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(12, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -1905,6 +2385,38 @@ uint8_t* SharingLog_DeviceSettings::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_is_wifi_enabled(), target); } + // optional int32 first_successful_transfer_date = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(8, this->_internal_first_successful_transfer_date(), target); + } + + // optional int32 previous_successful_transfer_date = 9; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(9, this->_internal_previous_successful_transfer_date(), target); + } + + // optional int32 lifetime_transfer_count = 10; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(10, this->_internal_lifetime_transfer_count(), target); + } + + // optional .location.nearby.proto.sharing.ContactAccess contact_access = 11; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 11, this->_internal_contact_access(), target); + } + + // optional .location.nearby.proto.sharing.IdentityVerification identity_verification = 12; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 12, this->_internal_identity_verification(), 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); @@ -1922,7 +2434,7 @@ size_t SharingLog_DeviceSettings::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x000000ffu) { // optional .location.nearby.proto.sharing.Visibility visibility = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -1960,6 +2472,35 @@ size_t SharingLog_DeviceSettings::ByteSizeLong() const { total_size += 1 + 1; } + // optional int32 first_successful_transfer_date = 8; + if (cached_has_bits & 0x00000080u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_first_successful_transfer_date()); + } + + } + if (cached_has_bits & 0x00000f00u) { + // optional int32 previous_successful_transfer_date = 9; + if (cached_has_bits & 0x00000100u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_previous_successful_transfer_date()); + } + + // optional int32 lifetime_transfer_count = 10; + if (cached_has_bits & 0x00000200u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_lifetime_transfer_count()); + } + + // optional .location.nearby.proto.sharing.ContactAccess contact_access = 11; + if (cached_has_bits & 0x00000400u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_contact_access()); + } + + // optional .location.nearby.proto.sharing.IdentityVerification identity_verification = 12; + if (cached_has_bits & 0x00000800u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_identity_verification()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -1982,7 +2523,7 @@ void SharingLog_DeviceSettings::MergeFrom(const SharingLog_DeviceSettings& from) (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { visibility_ = from.visibility_; } @@ -2004,6 +2545,24 @@ void SharingLog_DeviceSettings::MergeFrom(const SharingLog_DeviceSettings& from) if (cached_has_bits & 0x00000040u) { is_wifi_enabled_ = from.is_wifi_enabled_; } + if (cached_has_bits & 0x00000080u) { + first_successful_transfer_date_ = from.first_successful_transfer_date_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000f00u) { + if (cached_has_bits & 0x00000100u) { + previous_successful_transfer_date_ = from.previous_successful_transfer_date_; + } + if (cached_has_bits & 0x00000200u) { + lifetime_transfer_count_ = from.lifetime_transfer_count_; + } + if (cached_has_bits & 0x00000400u) { + contact_access_ = from.contact_access_; + } + if (cached_has_bits & 0x00000800u) { + identity_verification_ = from.identity_verification_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -2025,8 +2584,8 @@ void SharingLog_DeviceSettings::InternalSwap(SharingLog_DeviceSettings* other) { _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SharingLog_DeviceSettings, is_wifi_enabled_) - + sizeof(SharingLog_DeviceSettings::is_wifi_enabled_) + PROTOBUF_FIELD_OFFSET(SharingLog_DeviceSettings, identity_verification_) + + sizeof(SharingLog_DeviceSettings::identity_verification_) - PROTOBUF_FIELD_OFFSET(SharingLog_DeviceSettings, visibility_)>( reinterpret_cast(&visibility_), reinterpret_cast(&other->visibility_)); @@ -2497,19 +3056,19 @@ class SharingLog_EstablishConnection::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_status(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_session_id(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_transfer_position(HasBits* has_bits) { (*has_bits)[0] |= 16u; } + static void set_has_session_id(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_transfer_position(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } static void set_has_concurrent_connections(HasBits* has_bits) { - (*has_bits)[0] |= 64u; + (*has_bits)[0] |= 128u; } static void set_has_duration_millis(HasBits* has_bits) { - (*has_bits)[0] |= 32u; + (*has_bits)[0] |= 64u; } static const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& share_target_info(const SharingLog_EstablishConnection* msg); static void set_has_share_target_info(HasBits* has_bits) { @@ -2519,10 +3078,14 @@ class SharingLog_EstablishConnection::_Internal { (*has_bits)[0] |= 1u; } static void set_has_qr_code_flow(HasBits* has_bits) { - (*has_bits)[0] |= 128u; + (*has_bits)[0] |= 256u; } static void set_has_is_incoming_connection(HasBits* has_bits) { - (*has_bits)[0] |= 256u; + (*has_bits)[0] |= 512u; + } + static const ::PROTOBUF_NAMESPACE_ID::Duration& qr_code_receiver_connect_latency(const SharingLog_EstablishConnection* msg); + static void set_has_qr_code_receiver_connect_latency(HasBits* has_bits) { + (*has_bits)[0] |= 4u; } }; @@ -2530,6 +3093,14 @@ const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& SharingLog_EstablishConnection::_Internal::share_target_info(const SharingLog_EstablishConnection* msg) { return *msg->share_target_info_; } +const ::PROTOBUF_NAMESPACE_ID::Duration& +SharingLog_EstablishConnection::_Internal::qr_code_receiver_connect_latency(const SharingLog_EstablishConnection* msg) { + return *msg->qr_code_receiver_connect_latency_; +} +void SharingLog_EstablishConnection::clear_qr_code_receiver_connect_latency() { + if (qr_code_receiver_connect_latency_ != nullptr) qr_code_receiver_connect_latency_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} SharingLog_EstablishConnection::SharingLog_EstablishConnection(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { @@ -2556,6 +3127,11 @@ SharingLog_EstablishConnection::SharingLog_EstablishConnection(const SharingLog_ } else { share_target_info_ = nullptr; } + if (from._internal_has_qr_code_receiver_connect_latency()) { + qr_code_receiver_connect_latency_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from.qr_code_receiver_connect_latency_); + } else { + qr_code_receiver_connect_latency_ = nullptr; + } ::memcpy(&session_id_, &from.session_id_, static_cast(reinterpret_cast(&is_incoming_connection_) - reinterpret_cast(&session_id_)) + sizeof(is_incoming_connection_)); @@ -2584,6 +3160,7 @@ inline void SharingLog_EstablishConnection::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); referrer_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete share_target_info_; + if (this != internal_default_instance()) delete qr_code_receiver_connect_latency_; } void SharingLog_EstablishConnection::ArenaDtor(void* object) { @@ -2603,7 +3180,7 @@ void SharingLog_EstablishConnection::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000007u) { if (cached_has_bits & 0x00000001u) { referrer_name_.ClearNonDefaultToEmpty(); } @@ -2611,13 +3188,21 @@ void SharingLog_EstablishConnection::Clear() { GOOGLE_DCHECK(share_target_info_ != nullptr); share_target_info_->Clear(); } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(qr_code_receiver_connect_latency_ != nullptr); + qr_code_receiver_connect_latency_->Clear(); + } } - if (cached_has_bits & 0x000000fcu) { + if (cached_has_bits & 0x000000f8u) { ::memset(&session_id_, 0, static_cast( - reinterpret_cast(&qr_code_flow_) - - reinterpret_cast(&session_id_)) + sizeof(qr_code_flow_)); + reinterpret_cast(&concurrent_connections_) - + reinterpret_cast(&session_id_)) + sizeof(concurrent_connections_)); + } + if (cached_has_bits & 0x00000300u) { + ::memset(&qr_code_flow_, 0, static_cast( + reinterpret_cast(&is_incoming_connection_) - + reinterpret_cast(&qr_code_flow_)) + sizeof(is_incoming_connection_)); } - is_incoming_connection_ = false; _has_bits_.Clear(); _internal_metadata_.Clear(); } @@ -2695,7 +3280,7 @@ const char* SharingLog_EstablishConnection::_InternalParse(const char* ptr, ::PR } else goto handle_unusual; continue; - // optional bool qr_code_flow = 8; + // optional bool qr_code_flow = 8 [deprecated = true]; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { _Internal::set_has_qr_code_flow(&has_bits); @@ -2713,6 +3298,14 @@ const char* SharingLog_EstablishConnection::_InternalParse(const char* ptr, ::PR } else goto handle_unusual; continue; + // optional .google.protobuf.Duration qr_code_receiver_connect_latency = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_qr_code_receiver_connect_latency(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -2745,32 +3338,32 @@ uint8_t* SharingLog_EstablishConnection::_InternalSerialize( cached_has_bits = _has_bits_[0]; // optional .location.nearby.proto.sharing.EstablishConnectionStatus status = 1; - if (cached_has_bits & 0x00000008u) { + if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_status(), target); } // optional int64 session_id = 2; - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_session_id(), target); } // optional int32 transfer_position = 3; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_transfer_position(), target); } // optional int32 concurrent_connections = 4; - if (cached_has_bits & 0x00000040u) { + if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_concurrent_connections(), target); } // optional int64 duration_millis = 5; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->_internal_duration_millis(), target); } @@ -2789,18 +3382,26 @@ uint8_t* SharingLog_EstablishConnection::_InternalSerialize( 7, this->_internal_referrer_name(), target); } - // optional bool qr_code_flow = 8; - if (cached_has_bits & 0x00000080u) { + // optional bool qr_code_flow = 8 [deprecated = true]; + if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_qr_code_flow(), target); } // optional bool is_incoming_connection = 9; - if (cached_has_bits & 0x00000100u) { + if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(9, this->_internal_is_incoming_connection(), target); } + // optional .google.protobuf.Duration qr_code_receiver_connect_latency = 10; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::qr_code_receiver_connect_latency(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); @@ -2833,43 +3434,52 @@ size_t SharingLog_EstablishConnection::ByteSizeLong() const { *share_target_info_); } - // optional int64 session_id = 2; + // optional .google.protobuf.Duration qr_code_receiver_connect_latency = 10; if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *qr_code_receiver_connect_latency_); + } + + // optional int64 session_id = 2; + if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_session_id()); } // optional .location.nearby.proto.sharing.EstablishConnectionStatus status = 1; - if (cached_has_bits & 0x00000008u) { + if (cached_has_bits & 0x00000010u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status()); } // optional int32 transfer_position = 3; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_transfer_position()); } // optional int64 duration_millis = 5; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000040u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis()); } // optional int32 concurrent_connections = 4; - if (cached_has_bits & 0x00000040u) { + if (cached_has_bits & 0x00000080u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_concurrent_connections()); } - // optional bool qr_code_flow = 8; - if (cached_has_bits & 0x00000080u) { + } + if (cached_has_bits & 0x00000300u) { + // optional bool qr_code_flow = 8 [deprecated = true]; + if (cached_has_bits & 0x00000100u) { + total_size += 1 + 1; + } + + // optional bool is_incoming_connection = 9; + if (cached_has_bits & 0x00000200u) { total_size += 1 + 1; } } - // optional bool is_incoming_connection = 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(); } @@ -2899,27 +3509,33 @@ void SharingLog_EstablishConnection::MergeFrom(const SharingLog_EstablishConnect _internal_mutable_share_target_info()->::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo::MergeFrom(from._internal_share_target_info()); } if (cached_has_bits & 0x00000004u) { - session_id_ = from.session_id_; + _internal_mutable_qr_code_receiver_connect_latency()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(from._internal_qr_code_receiver_connect_latency()); } if (cached_has_bits & 0x00000008u) { - status_ = from.status_; + session_id_ = from.session_id_; } if (cached_has_bits & 0x00000010u) { - transfer_position_ = from.transfer_position_; + status_ = from.status_; } if (cached_has_bits & 0x00000020u) { - duration_millis_ = from.duration_millis_; + transfer_position_ = from.transfer_position_; } if (cached_has_bits & 0x00000040u) { - concurrent_connections_ = from.concurrent_connections_; + duration_millis_ = from.duration_millis_; } if (cached_has_bits & 0x00000080u) { - qr_code_flow_ = from.qr_code_flow_; + concurrent_connections_ = from.concurrent_connections_; } _has_bits_[0] |= cached_has_bits; } - if (cached_has_bits & 0x00000100u) { - _internal_set_is_incoming_connection(from._internal_is_incoming_connection()); + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + qr_code_flow_ = from.qr_code_flow_; + } + if (cached_has_bits & 0x00000200u) { + is_incoming_connection_ = from.is_incoming_connection_; + } + _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); } @@ -4250,6 +4866,9 @@ class SharingLog_ScanForShareTargetsStart::_Internal { static void set_has_referrer_name(HasBits* has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_use_qr_code(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } }; SharingLog_ScanForShareTargetsStart::SharingLog_ScanForShareTargetsStart(::PROTOBUF_NAMESPACE_ID::Arena* arena, @@ -4274,8 +4893,8 @@ SharingLog_ScanForShareTargetsStart::SharingLog_ScanForShareTargetsStart(const S GetArenaForAllocation()); } ::memcpy(&session_id_, &from.session_id_, - static_cast(reinterpret_cast(&flow_id_) - - reinterpret_cast(&session_id_)) + sizeof(flow_id_)); + static_cast(reinterpret_cast(&use_qr_code_) - + reinterpret_cast(&session_id_)) + sizeof(use_qr_code_)); // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.ScanForShareTargetsStart) } @@ -4286,8 +4905,8 @@ referrer_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStri #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&session_id_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&flow_id_) - - reinterpret_cast(&session_id_)) + sizeof(flow_id_)); + 0, static_cast(reinterpret_cast(&use_qr_code_) - + reinterpret_cast(&session_id_)) + sizeof(use_qr_code_)); } SharingLog_ScanForShareTargetsStart::~SharingLog_ScanForShareTargetsStart() { @@ -4322,10 +4941,10 @@ void SharingLog_ScanForShareTargetsStart::Clear() { if (cached_has_bits & 0x00000001u) { referrer_name_.ClearNonDefaultToEmpty(); } - if (cached_has_bits & 0x0000001eu) { + if (cached_has_bits & 0x0000003eu) { ::memset(&session_id_, 0, static_cast( - reinterpret_cast(&flow_id_) - - reinterpret_cast(&session_id_)) + sizeof(flow_id_)); + reinterpret_cast(&use_qr_code_) - + reinterpret_cast(&session_id_)) + sizeof(use_qr_code_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -4391,6 +5010,15 @@ const char* SharingLog_ScanForShareTargetsStart::_InternalParse(const char* ptr, } else goto handle_unusual; continue; + // optional bool use_qr_code = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_use_qr_code(&has_bits); + use_qr_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -4454,6 +5082,12 @@ uint8_t* SharingLog_ScanForShareTargetsStart::_InternalSerialize( 5, this->_internal_referrer_name(), target); } + // optional bool use_qr_code = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_use_qr_code(), 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); @@ -4471,7 +5105,7 @@ size_t SharingLog_ScanForShareTargetsStart::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x0000003fu) { // optional string referrer_name = 5; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -4501,6 +5135,11 @@ size_t SharingLog_ScanForShareTargetsStart::ByteSizeLong() const { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_flow_id()); } + // optional bool use_qr_code = 6; + 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(); @@ -4523,7 +5162,7 @@ void SharingLog_ScanForShareTargetsStart::MergeFrom(const SharingLog_ScanForShar (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x0000003fu) { if (cached_has_bits & 0x00000001u) { _internal_set_referrer_name(from._internal_referrer_name()); } @@ -4539,6 +5178,9 @@ void SharingLog_ScanForShareTargetsStart::MergeFrom(const SharingLog_ScanForShar if (cached_has_bits & 0x00000010u) { flow_id_ = from.flow_id_; } + if (cached_has_bits & 0x00000020u) { + use_qr_code_ = from.use_qr_code_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -4567,8 +5209,8 @@ void SharingLog_ScanForShareTargetsStart::InternalSwap(SharingLog_ScanForShareTa &other->referrer_name_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SharingLog_ScanForShareTargetsStart, flow_id_) - + sizeof(SharingLog_ScanForShareTargetsStart::flow_id_) + PROTOBUF_FIELD_OFFSET(SharingLog_ScanForShareTargetsStart, use_qr_code_) + + sizeof(SharingLog_ScanForShareTargetsStart::use_qr_code_) - PROTOBUF_FIELD_OFFSET(SharingLog_ScanForShareTargetsStart, session_id_)>( reinterpret_cast(&session_id_), reinterpret_cast(&other->session_id_)); @@ -6090,26 +6732,38 @@ class SharingLog_EventMetadata::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_use_case(HasBits* has_bits) { - (*has_bits)[0] |= 1u; - } - static void set_has_initial_opt_in(HasBits* has_bits) { - (*has_bits)[0] |= 2u; - } - static void set_has_opt_in(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_initial_enable_status(HasBits* has_bits) { - (*has_bits)[0] |= 8u; - } - static void set_has_flow_id(HasBits* has_bits) { (*has_bits)[0] |= 16u; } - static void set_has_session_id(HasBits* has_bits) { + static void set_has_initial_opt_in(HasBits* has_bits) { (*has_bits)[0] |= 32u; } - static void set_has_vendor_id(HasBits* has_bits) { + static void set_has_opt_in(HasBits* has_bits) { (*has_bits)[0] |= 64u; } + static void set_has_initial_enable_status(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_flow_id(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_session_id(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } + static void set_has_vendor_id(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_cloud_sharing_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_cloud_receiver_session_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_external_provider_name(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_external_provider_id(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } }; SharingLog_EventMetadata::SharingLog_EventMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena, @@ -6125,6 +6779,38 @@ SharingLog_EventMetadata::SharingLog_EventMetadata(const SharingLog_EventMetadat : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom(from._internal_metadata_); + cloud_sharing_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + cloud_sharing_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_cloud_sharing_id()) { + cloud_sharing_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_cloud_sharing_id(), + GetArenaForAllocation()); + } + cloud_receiver_session_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + cloud_receiver_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_cloud_receiver_session_id()) { + cloud_receiver_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_cloud_receiver_session_id(), + GetArenaForAllocation()); + } + external_provider_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + external_provider_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_external_provider_name()) { + external_provider_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_external_provider_name(), + GetArenaForAllocation()); + } + external_provider_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + external_provider_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_external_provider_id()) { + external_provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_external_provider_id(), + GetArenaForAllocation()); + } ::memcpy(&use_case_, &from.use_case_, static_cast(reinterpret_cast(&vendor_id_) - reinterpret_cast(&use_case_)) + sizeof(vendor_id_)); @@ -6132,6 +6818,22 @@ SharingLog_EventMetadata::SharingLog_EventMetadata(const SharingLog_EventMetadat } inline void SharingLog_EventMetadata::SharedCtor() { +cloud_sharing_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + cloud_sharing_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +cloud_receiver_session_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + cloud_receiver_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +external_provider_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + external_provider_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +external_provider_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + external_provider_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&use_case_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&vendor_id_) - @@ -6147,6 +6849,10 @@ SharingLog_EventMetadata::~SharingLog_EventMetadata() { inline void SharingLog_EventMetadata::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + cloud_sharing_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + cloud_receiver_session_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + external_provider_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + external_provider_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } void SharingLog_EventMetadata::ArenaDtor(void* object) { @@ -6166,10 +6872,29 @@ void SharingLog_EventMetadata::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + cloud_sharing_id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + cloud_receiver_session_id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + external_provider_name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + external_provider_id_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x000000f0u) { ::memset(&use_case_, 0, static_cast( + reinterpret_cast(&initial_enable_status_) - + reinterpret_cast(&use_case_)) + sizeof(initial_enable_status_)); + } + if (cached_has_bits & 0x00000700u) { + ::memset(&flow_id_, 0, static_cast( reinterpret_cast(&vendor_id_) - - reinterpret_cast(&use_case_)) + sizeof(vendor_id_)); + reinterpret_cast(&flow_id_)) + sizeof(vendor_id_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -6195,7 +6920,7 @@ const char* SharingLog_EventMetadata::_InternalParse(const char* ptr, ::PROTOBUF } else goto handle_unusual; continue; - // optional bool initial_opt_in = 2; + // optional bool initial_opt_in = 2 [deprecated = true]; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { _Internal::set_has_initial_opt_in(&has_bits); @@ -6204,7 +6929,7 @@ const char* SharingLog_EventMetadata::_InternalParse(const char* ptr, ::PROTOBUF } else goto handle_unusual; continue; - // optional bool opt_in = 3; + // optional bool opt_in = 3 [deprecated = true]; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _Internal::set_has_opt_in(&has_bits); @@ -6213,7 +6938,7 @@ const char* SharingLog_EventMetadata::_InternalParse(const char* ptr, ::PROTOBUF } else goto handle_unusual; continue; - // optional bool initial_enable_status = 4; + // optional bool initial_enable_status = 4 [deprecated = true]; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { _Internal::set_has_initial_enable_status(&has_bits); @@ -6249,6 +6974,42 @@ const char* SharingLog_EventMetadata::_InternalParse(const char* ptr, ::PROTOBUF } else goto handle_unusual; continue; + // optional string cloud_sharing_id = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_cloud_sharing_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string cloud_receiver_session_id = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_cloud_receiver_session_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string external_provider_name = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + auto str = _internal_mutable_external_provider_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string external_provider_id = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + auto str = _internal_mutable_external_provider_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -6281,48 +7042,72 @@ uint8_t* SharingLog_EventMetadata::_InternalSerialize( cached_has_bits = _has_bits_[0]; // optional .location.nearby.proto.sharing.SharingUseCase use_case = 1; - if (cached_has_bits & 0x00000001u) { + if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_use_case(), target); } - // optional bool initial_opt_in = 2; - if (cached_has_bits & 0x00000002u) { + // optional bool initial_opt_in = 2 [deprecated = true]; + if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_initial_opt_in(), target); } - // optional bool opt_in = 3; - if (cached_has_bits & 0x00000004u) { + // optional bool opt_in = 3 [deprecated = true]; + if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_opt_in(), target); } - // optional bool initial_enable_status = 4; - if (cached_has_bits & 0x00000008u) { + // optional bool initial_enable_status = 4 [deprecated = true]; + if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_initial_enable_status(), target); } // optional int64 flow_id = 5; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000100u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->_internal_flow_id(), target); } // optional int64 session_id = 6; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000200u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(6, this->_internal_session_id(), target); } // optional int32 vendor_id = 7; - if (cached_has_bits & 0x00000040u) { + if (cached_has_bits & 0x00000400u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_vendor_id(), target); } + // optional string cloud_sharing_id = 8; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 8, this->_internal_cloud_sharing_id(), target); + } + + // optional string cloud_receiver_session_id = 9; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 9, this->_internal_cloud_receiver_session_id(), target); + } + + // optional string external_provider_name = 10; + if (cached_has_bits & 0x00000004u) { + target = stream->WriteStringMaybeAliased( + 10, this->_internal_external_provider_name(), target); + } + + // optional string external_provider_id = 11; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteStringMaybeAliased( + 11, this->_internal_external_provider_id(), 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); @@ -6340,40 +7125,70 @@ size_t SharingLog_EventMetadata::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { - // optional .location.nearby.proto.sharing.SharingUseCase use_case = 1; + if (cached_has_bits & 0x000000ffu) { + // optional string cloud_sharing_id = 8; if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_cloud_sharing_id()); + } + + // optional string cloud_receiver_session_id = 9; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_cloud_receiver_session_id()); + } + + // optional string external_provider_name = 10; + if (cached_has_bits & 0x00000004u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_external_provider_name()); + } + + // optional string external_provider_id = 11; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_external_provider_id()); + } + + // optional .location.nearby.proto.sharing.SharingUseCase use_case = 1; + if (cached_has_bits & 0x00000010u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_use_case()); } - // optional bool initial_opt_in = 2; - if (cached_has_bits & 0x00000002u) { + // optional bool initial_opt_in = 2 [deprecated = true]; + if (cached_has_bits & 0x00000020u) { total_size += 1 + 1; } - // optional bool opt_in = 3; - if (cached_has_bits & 0x00000004u) { + // optional bool opt_in = 3 [deprecated = true]; + if (cached_has_bits & 0x00000040u) { total_size += 1 + 1; } - // optional bool initial_enable_status = 4; - if (cached_has_bits & 0x00000008u) { + // optional bool initial_enable_status = 4 [deprecated = true]; + if (cached_has_bits & 0x00000080u) { total_size += 1 + 1; } + } + if (cached_has_bits & 0x00000700u) { // optional int64 flow_id = 5; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000100u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_flow_id()); } // optional int64 session_id = 6; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000200u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_session_id()); } // optional int32 vendor_id = 7; - if (cached_has_bits & 0x00000040u) { + if (cached_has_bits & 0x00000400u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_vendor_id()); } @@ -6399,26 +7214,41 @@ void SharingLog_EventMetadata::MergeFrom(const SharingLog_EventMetadata& from) { (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { - use_case_ = from.use_case_; + _internal_set_cloud_sharing_id(from._internal_cloud_sharing_id()); } if (cached_has_bits & 0x00000002u) { - initial_opt_in_ = from.initial_opt_in_; + _internal_set_cloud_receiver_session_id(from._internal_cloud_receiver_session_id()); } if (cached_has_bits & 0x00000004u) { - opt_in_ = from.opt_in_; + _internal_set_external_provider_name(from._internal_external_provider_name()); } if (cached_has_bits & 0x00000008u) { - initial_enable_status_ = from.initial_enable_status_; + _internal_set_external_provider_id(from._internal_external_provider_id()); } if (cached_has_bits & 0x00000010u) { - flow_id_ = from.flow_id_; + use_case_ = from.use_case_; } if (cached_has_bits & 0x00000020u) { - session_id_ = from.session_id_; + initial_opt_in_ = from.initial_opt_in_; } if (cached_has_bits & 0x00000040u) { + opt_in_ = from.opt_in_; + } + if (cached_has_bits & 0x00000080u) { + initial_enable_status_ = from.initial_enable_status_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000100u) { + flow_id_ = from.flow_id_; + } + if (cached_has_bits & 0x00000200u) { + session_id_ = from.session_id_; + } + if (cached_has_bits & 0x00000400u) { vendor_id_ = from.vendor_id_; } _has_bits_[0] |= cached_has_bits; @@ -6439,8 +7269,30 @@ bool SharingLog_EventMetadata::IsInitialized() const { void SharingLog_EventMetadata::InternalSwap(SharingLog_EventMetadata* 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(), + &cloud_sharing_id_, lhs_arena, + &other->cloud_sharing_id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &cloud_receiver_session_id_, lhs_arena, + &other->cloud_receiver_session_id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &external_provider_name_, lhs_arena, + &other->external_provider_name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &external_provider_id_, lhs_arena, + &other->external_provider_id_, rhs_arena + ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SharingLog_EventMetadata, vendor_id_) + sizeof(SharingLog_EventMetadata::vendor_id_) @@ -6461,26 +7313,29 @@ class SharingLog_DiscoverShareTarget::_Internal { using HasBits = decltype(std::declval()._has_bits_); static const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& share_target_info(const SharingLog_DiscoverShareTarget* msg); static void set_has_share_target_info(HasBits* has_bits) { - (*has_bits)[0] |= 2u; + (*has_bits)[0] |= 4u; } static const ::PROTOBUF_NAMESPACE_ID::Duration& duration_since_scanning(const SharingLog_DiscoverShareTarget* msg); static void set_has_duration_since_scanning(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_session_id(HasBits* has_bits) { (*has_bits)[0] |= 8u; } - static void set_has_flow_id(HasBits* has_bits) { + static void set_has_session_id(HasBits* has_bits) { (*has_bits)[0] |= 16u; } + static void set_has_flow_id(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } static void set_has_referrer_name(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_latency_since_activity_start_millis(HasBits* has_bits) { - (*has_bits)[0] |= 64u; + (*has_bits)[0] |= 128u; } static void set_has_scan_type(HasBits* has_bits) { - (*has_bits)[0] |= 32u; + (*has_bits)[0] |= 64u; + } + static void set_has_cloud_receiver_session_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; } }; @@ -6494,7 +7349,7 @@ SharingLog_DiscoverShareTarget::_Internal::duration_since_scanning(const Sharing } void SharingLog_DiscoverShareTarget::clear_duration_since_scanning() { if (duration_since_scanning_ != nullptr) duration_since_scanning_->Clear(); - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000008u; } SharingLog_DiscoverShareTarget::SharingLog_DiscoverShareTarget(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) @@ -6517,6 +7372,14 @@ SharingLog_DiscoverShareTarget::SharingLog_DiscoverShareTarget(const SharingLog_ referrer_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_referrer_name(), GetArenaForAllocation()); } + cloud_receiver_session_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + cloud_receiver_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_cloud_receiver_session_id()) { + cloud_receiver_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_cloud_receiver_session_id(), + GetArenaForAllocation()); + } if (from._internal_has_share_target_info()) { share_target_info_ = new ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo(*from.share_target_info_); } else { @@ -6538,6 +7401,10 @@ referrer_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStri #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING referrer_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +cloud_receiver_session_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + cloud_receiver_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&share_target_info_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&scan_type_) - @@ -6555,6 +7422,7 @@ SharingLog_DiscoverShareTarget::~SharingLog_DiscoverShareTarget() { inline void SharingLog_DiscoverShareTarget::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); referrer_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + cloud_receiver_session_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete share_target_info_; if (this != internal_default_instance()) delete duration_since_scanning_; } @@ -6576,20 +7444,23 @@ void SharingLog_DiscoverShareTarget::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { referrer_name_.ClearNonDefaultToEmpty(); } if (cached_has_bits & 0x00000002u) { + cloud_receiver_session_id_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { GOOGLE_DCHECK(share_target_info_ != nullptr); share_target_info_->Clear(); } - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { GOOGLE_DCHECK(duration_since_scanning_ != nullptr); duration_since_scanning_->Clear(); } } - if (cached_has_bits & 0x00000078u) { + if (cached_has_bits & 0x000000f0u) { ::memset(&session_id_, 0, static_cast( reinterpret_cast(&scan_type_) - reinterpret_cast(&session_id_)) + sizeof(scan_type_)); @@ -6671,6 +7542,15 @@ const char* SharingLog_DiscoverShareTarget::_InternalParse(const char* ptr, ::PR } else goto handle_unusual; continue; + // optional string cloud_receiver_session_id = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_cloud_receiver_session_id(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -6703,7 +7583,7 @@ uint8_t* SharingLog_DiscoverShareTarget::_InternalSerialize( cached_has_bits = _has_bits_[0]; // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; - if (cached_has_bits & 0x00000002u) { + if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6711,7 +7591,7 @@ uint8_t* SharingLog_DiscoverShareTarget::_InternalSerialize( } // optional .google.protobuf.Duration duration_since_scanning = 2; - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6719,13 +7599,13 @@ uint8_t* SharingLog_DiscoverShareTarget::_InternalSerialize( } // optional int64 session_id = 3; - if (cached_has_bits & 0x00000008u) { + if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_session_id(), target); } // optional int64 flow_id = 4; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_flow_id(), target); } @@ -6737,18 +7617,24 @@ uint8_t* SharingLog_DiscoverShareTarget::_InternalSerialize( } // optional int64 latency_since_activity_start_millis = 6 [default = -1]; - if (cached_has_bits & 0x00000040u) { + if (cached_has_bits & 0x00000080u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(6, this->_internal_latency_since_activity_start_millis(), target); } // optional .location.nearby.proto.sharing.ScanType scan_type = 7; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000040u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 7, this->_internal_scan_type(), target); } + // optional string cloud_receiver_session_id = 8; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 8, this->_internal_cloud_receiver_session_id(), 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); @@ -6766,7 +7652,7 @@ size_t SharingLog_DiscoverShareTarget::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x000000ffu) { // optional string referrer_name = 5; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -6774,38 +7660,45 @@ size_t SharingLog_DiscoverShareTarget::ByteSizeLong() const { this->_internal_referrer_name()); } - // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; + // optional string cloud_receiver_session_id = 8; if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_cloud_receiver_session_id()); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; + if (cached_has_bits & 0x00000004u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *share_target_info_); } // optional .google.protobuf.Duration duration_since_scanning = 2; - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *duration_since_scanning_); } // optional int64 session_id = 3; - if (cached_has_bits & 0x00000008u) { + if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_session_id()); } // optional int64 flow_id = 4; - if (cached_has_bits & 0x00000010u) { + if (cached_has_bits & 0x00000020u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_flow_id()); } // optional .location.nearby.proto.sharing.ScanType scan_type = 7; - if (cached_has_bits & 0x00000020u) { + if (cached_has_bits & 0x00000040u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_scan_type()); } // optional int64 latency_since_activity_start_millis = 6 [default = -1]; - if (cached_has_bits & 0x00000040u) { + if (cached_has_bits & 0x00000080u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_latency_since_activity_start_millis()); } @@ -6831,26 +7724,29 @@ void SharingLog_DiscoverShareTarget::MergeFrom(const SharingLog_DiscoverShareTar (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_referrer_name(from._internal_referrer_name()); } if (cached_has_bits & 0x00000002u) { - _internal_mutable_share_target_info()->::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo::MergeFrom(from._internal_share_target_info()); + _internal_set_cloud_receiver_session_id(from._internal_cloud_receiver_session_id()); } if (cached_has_bits & 0x00000004u) { - _internal_mutable_duration_since_scanning()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(from._internal_duration_since_scanning()); + _internal_mutable_share_target_info()->::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo::MergeFrom(from._internal_share_target_info()); } if (cached_has_bits & 0x00000008u) { - session_id_ = from.session_id_; + _internal_mutable_duration_since_scanning()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(from._internal_duration_since_scanning()); } if (cached_has_bits & 0x00000010u) { - flow_id_ = from.flow_id_; + session_id_ = from.session_id_; } if (cached_has_bits & 0x00000020u) { - scan_type_ = from.scan_type_; + flow_id_ = from.flow_id_; } if (cached_has_bits & 0x00000040u) { + scan_type_ = from.scan_type_; + } + if (cached_has_bits & 0x00000080u) { latency_since_activity_start_millis_ = from.latency_since_activity_start_millis_; } _has_bits_[0] |= cached_has_bits; @@ -6880,6 +7776,11 @@ void SharingLog_DiscoverShareTarget::InternalSwap(SharingLog_DiscoverShareTarget &referrer_name_, lhs_arena, &other->referrer_name_, rhs_arena ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &cloud_receiver_session_id_, lhs_arena, + &other->cloud_receiver_session_id_, rhs_arena + ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SharingLog_DiscoverShareTarget, scan_type_) + sizeof(SharingLog_DiscoverShareTarget::scan_type_) @@ -7468,12 +8369,24 @@ class SharingLog_DescribeAttachments::_Internal { static void set_has_attachments_info(HasBits* has_bits) { (*has_bits)[0] |= 1u; } + static const ::PROTOBUF_NAMESPACE_ID::Duration& download_duration(const SharingLog_DescribeAttachments* msg); + static void set_has_download_duration(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } }; const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& SharingLog_DescribeAttachments::_Internal::attachments_info(const SharingLog_DescribeAttachments* msg) { return *msg->attachments_info_; } +const ::PROTOBUF_NAMESPACE_ID::Duration& +SharingLog_DescribeAttachments::_Internal::download_duration(const SharingLog_DescribeAttachments* msg) { + return *msg->download_duration_; +} +void SharingLog_DescribeAttachments::clear_download_duration() { + if (download_duration_ != nullptr) download_duration_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} SharingLog_DescribeAttachments::SharingLog_DescribeAttachments(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { @@ -7492,11 +8405,19 @@ SharingLog_DescribeAttachments::SharingLog_DescribeAttachments(const SharingLog_ } else { attachments_info_ = nullptr; } + if (from._internal_has_download_duration()) { + download_duration_ = new ::PROTOBUF_NAMESPACE_ID::Duration(*from.download_duration_); + } else { + download_duration_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.DescribeAttachments) } inline void SharingLog_DescribeAttachments::SharedCtor() { -attachments_info_ = nullptr; +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&attachments_info_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&download_duration_) - + reinterpret_cast(&attachments_info_)) + sizeof(download_duration_)); } SharingLog_DescribeAttachments::~SharingLog_DescribeAttachments() { @@ -7509,6 +8430,7 @@ SharingLog_DescribeAttachments::~SharingLog_DescribeAttachments() { inline void SharingLog_DescribeAttachments::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete attachments_info_; + if (this != internal_default_instance()) delete download_duration_; } void SharingLog_DescribeAttachments::ArenaDtor(void* object) { @@ -7528,9 +8450,15 @@ void SharingLog_DescribeAttachments::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(attachments_info_ != nullptr); - attachments_info_->Clear(); + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(attachments_info_ != nullptr); + attachments_info_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(download_duration_ != nullptr); + download_duration_->Clear(); + } } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -7551,6 +8479,14 @@ const char* SharingLog_DescribeAttachments::_InternalParse(const char* ptr, ::PR } else goto handle_unusual; continue; + // optional .google.protobuf.Duration download_duration = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_download_duration(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -7590,6 +8526,14 @@ uint8_t* SharingLog_DescribeAttachments::_InternalSerialize( 1, _Internal::attachments_info(this), target, stream); } + // optional .google.protobuf.Duration download_duration = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::download_duration(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); @@ -7606,14 +8550,23 @@ size_t SharingLog_DescribeAttachments::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *attachments_info_); - } + if (cached_has_bits & 0x00000003u) { + // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *attachments_info_); + } + // optional .google.protobuf.Duration download_duration = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *download_duration_); + } + + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); } @@ -7634,8 +8587,14 @@ void SharingLog_DescribeAttachments::MergeFrom(const SharingLog_DescribeAttachme uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from._internal_has_attachments_info()) { - _internal_mutable_attachments_info()->::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo::MergeFrom(from._internal_attachments_info()); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_attachments_info()->::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo::MergeFrom(from._internal_attachments_info()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_download_duration()->::PROTOBUF_NAMESPACE_ID::Duration::MergeFrom(from._internal_download_duration()); + } } _internal_metadata_.MergeFrom(from._internal_metadata_); } @@ -7655,7 +8614,12 @@ void SharingLog_DescribeAttachments::InternalSwap(SharingLog_DescribeAttachments using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); - swap(attachments_info_, other->attachments_info_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SharingLog_DescribeAttachments, download_duration_) + + sizeof(SharingLog_DescribeAttachments::download_duration_) + - PROTOBUF_FIELD_OFFSET(SharingLog_DescribeAttachments, attachments_info_)>( + reinterpret_cast(&attachments_info_), + reinterpret_cast(&other->attachments_info_)); } std::string SharingLog_DescribeAttachments::GetTypeName() const { @@ -8538,27 +9502,41 @@ class SharingLog_SendAttachmentsStart::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_session_id(HasBits* has_bits) { - (*has_bits)[0] |= 2u; + (*has_bits)[0] |= 4u; } static const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& attachments_info(const SharingLog_SendAttachmentsStart* msg); static void set_has_attachments_info(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_transfer_position(HasBits* has_bits) { - (*has_bits)[0] |= 4u; - } - static void set_has_concurrent_connections(HasBits* has_bits) { (*has_bits)[0] |= 8u; } - static void set_has_qr_code_flow(HasBits* has_bits) { + static void set_has_concurrent_connections(HasBits* has_bits) { (*has_bits)[0] |= 16u; } + static void set_has_qr_code_flow(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& share_target_info(const SharingLog_SendAttachmentsStart* msg); + static void set_has_share_target_info(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_advanced_protection_enabled(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_advanced_protection_mismatch(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } }; const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& SharingLog_SendAttachmentsStart::_Internal::attachments_info(const SharingLog_SendAttachmentsStart* msg) { return *msg->attachments_info_; } +const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& +SharingLog_SendAttachmentsStart::_Internal::share_target_info(const SharingLog_SendAttachmentsStart* msg) { + return *msg->share_target_info_; +} SharingLog_SendAttachmentsStart::SharingLog_SendAttachmentsStart(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { @@ -8577,17 +9555,22 @@ SharingLog_SendAttachmentsStart::SharingLog_SendAttachmentsStart(const SharingLo } else { attachments_info_ = nullptr; } + if (from._internal_has_share_target_info()) { + share_target_info_ = new ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo(*from.share_target_info_); + } else { + share_target_info_ = nullptr; + } ::memcpy(&session_id_, &from.session_id_, - static_cast(reinterpret_cast(&qr_code_flow_) - - reinterpret_cast(&session_id_)) + sizeof(qr_code_flow_)); + static_cast(reinterpret_cast(&advanced_protection_mismatch_) - + reinterpret_cast(&session_id_)) + sizeof(advanced_protection_mismatch_)); // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart) } inline void SharingLog_SendAttachmentsStart::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&attachments_info_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&qr_code_flow_) - - reinterpret_cast(&attachments_info_)) + sizeof(qr_code_flow_)); + 0, static_cast(reinterpret_cast(&advanced_protection_mismatch_) - + reinterpret_cast(&attachments_info_)) + sizeof(advanced_protection_mismatch_)); } SharingLog_SendAttachmentsStart::~SharingLog_SendAttachmentsStart() { @@ -8600,6 +9583,7 @@ SharingLog_SendAttachmentsStart::~SharingLog_SendAttachmentsStart() { inline void SharingLog_SendAttachmentsStart::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete attachments_info_; + if (this != internal_default_instance()) delete share_target_info_; } void SharingLog_SendAttachmentsStart::ArenaDtor(void* object) { @@ -8619,14 +9603,20 @@ void SharingLog_SendAttachmentsStart::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - GOOGLE_DCHECK(attachments_info_ != nullptr); - attachments_info_->Clear(); + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(attachments_info_ != nullptr); + attachments_info_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(share_target_info_ != nullptr); + share_target_info_->Clear(); + } } - if (cached_has_bits & 0x0000001eu) { + if (cached_has_bits & 0x000000fcu) { ::memset(&session_id_, 0, static_cast( - reinterpret_cast(&qr_code_flow_) - - reinterpret_cast(&session_id_)) + sizeof(qr_code_flow_)); + reinterpret_cast(&advanced_protection_mismatch_) - + reinterpret_cast(&session_id_)) + sizeof(advanced_protection_mismatch_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -8674,7 +9664,7 @@ const char* SharingLog_SendAttachmentsStart::_InternalParse(const char* ptr, ::P } else goto handle_unusual; continue; - // optional bool qr_code_flow = 5; + // optional bool qr_code_flow = 5 [deprecated = true]; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { _Internal::set_has_qr_code_flow(&has_bits); @@ -8683,6 +9673,32 @@ const char* SharingLog_SendAttachmentsStart::_InternalParse(const char* ptr, ::P } else goto handle_unusual; continue; + // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_share_target_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool advanced_protection_enabled = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_advanced_protection_enabled(&has_bits); + advanced_protection_enabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool advanced_protection_mismatch = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_advanced_protection_mismatch(&has_bits); + advanced_protection_mismatch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -8715,7 +9731,7 @@ uint8_t* SharingLog_SendAttachmentsStart::_InternalSerialize( cached_has_bits = _has_bits_[0]; // optional int64 session_id = 1; - if (cached_has_bits & 0x00000002u) { + if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_session_id(), target); } @@ -8729,23 +9745,43 @@ uint8_t* SharingLog_SendAttachmentsStart::_InternalSerialize( } // optional int32 transfer_position = 3; - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_transfer_position(), target); } // optional int32 concurrent_connections = 4; - if (cached_has_bits & 0x00000008u) { + if (cached_has_bits & 0x00000010u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_concurrent_connections(), target); } - // optional bool qr_code_flow = 5; - if (cached_has_bits & 0x00000010u) { + // optional bool qr_code_flow = 5 [deprecated = true]; + if (cached_has_bits & 0x00000020u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_qr_code_flow(), target); } + // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 6; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::share_target_info(this), target, stream); + } + + // optional bool advanced_protection_enabled = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_advanced_protection_enabled(), target); + } + + // optional bool advanced_protection_mismatch = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_advanced_protection_mismatch(), 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); @@ -8763,7 +9799,7 @@ size_t SharingLog_SendAttachmentsStart::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x000000ffu) { // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 2; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -8771,23 +9807,40 @@ size_t SharingLog_SendAttachmentsStart::ByteSizeLong() const { *attachments_info_); } - // optional int64 session_id = 1; + // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 6; if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *share_target_info_); + } + + // optional int64 session_id = 1; + if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_session_id()); } // optional int32 transfer_position = 3; - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_transfer_position()); } // optional int32 concurrent_connections = 4; - if (cached_has_bits & 0x00000008u) { + if (cached_has_bits & 0x00000010u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_concurrent_connections()); } - // optional bool qr_code_flow = 5; - if (cached_has_bits & 0x00000010u) { + // optional bool qr_code_flow = 5 [deprecated = true]; + if (cached_has_bits & 0x00000020u) { + total_size += 1 + 1; + } + + // optional bool advanced_protection_enabled = 7; + if (cached_has_bits & 0x00000040u) { + total_size += 1 + 1; + } + + // optional bool advanced_protection_mismatch = 8; + if (cached_has_bits & 0x00000080u) { total_size += 1 + 1; } @@ -8813,22 +9866,31 @@ void SharingLog_SendAttachmentsStart::MergeFrom(const SharingLog_SendAttachments (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_mutable_attachments_info()->::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo::MergeFrom(from._internal_attachments_info()); } if (cached_has_bits & 0x00000002u) { - session_id_ = from.session_id_; + _internal_mutable_share_target_info()->::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo::MergeFrom(from._internal_share_target_info()); } if (cached_has_bits & 0x00000004u) { - transfer_position_ = from.transfer_position_; + session_id_ = from.session_id_; } if (cached_has_bits & 0x00000008u) { - concurrent_connections_ = from.concurrent_connections_; + transfer_position_ = from.transfer_position_; } if (cached_has_bits & 0x00000010u) { + concurrent_connections_ = from.concurrent_connections_; + } + if (cached_has_bits & 0x00000020u) { qr_code_flow_ = from.qr_code_flow_; } + if (cached_has_bits & 0x00000040u) { + advanced_protection_enabled_ = from.advanced_protection_enabled_; + } + if (cached_has_bits & 0x00000080u) { + advanced_protection_mismatch_ = from.advanced_protection_mismatch_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -8850,8 +9912,8 @@ void SharingLog_SendAttachmentsStart::InternalSwap(SharingLog_SendAttachmentsSta _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SharingLog_SendAttachmentsStart, qr_code_flow_) - + sizeof(SharingLog_SendAttachmentsStart::qr_code_flow_) + PROTOBUF_FIELD_OFFSET(SharingLog_SendAttachmentsStart, advanced_protection_mismatch_) + + sizeof(SharingLog_SendAttachmentsStart::advanced_protection_mismatch_) - PROTOBUF_FIELD_OFFSET(SharingLog_SendAttachmentsStart, attachments_info_)>( reinterpret_cast(&attachments_info_), reinterpret_cast(&other->attachments_info_)); @@ -8899,6 +9961,24 @@ class SharingLog_SendAttachmentsEnd::_Internal { static void set_has_connection_layer_status(HasBits* has_bits) { (*has_bits)[0] |= 512u; } + static void set_has_first_successful_transfer_date(HasBits* has_bits) { + (*has_bits)[0] |= 1024u; + } + static void set_has_previous_successful_transfer_date(HasBits* has_bits) { + (*has_bits)[0] |= 2048u; + } + static void set_has_lifetime_transfer_count(HasBits* has_bits) { + (*has_bits)[0] |= 4096u; + } + static void set_has_connection_medium(HasBits* has_bits) { + (*has_bits)[0] |= 8192u; + } + static void set_has_data_usage(HasBits* has_bits) { + (*has_bits)[0] |= 16384u; + } + static void set_has_is_mutual_contact(HasBits* has_bits) { + (*has_bits)[0] |= 32768u; + } }; const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& @@ -8941,8 +10021,8 @@ SharingLog_SendAttachmentsEnd::SharingLog_SendAttachmentsEnd(const SharingLog_Se share_target_info_ = nullptr; } ::memcpy(&session_id_, &from.session_id_, - static_cast(reinterpret_cast(&connection_layer_status_) - - reinterpret_cast(&session_id_)) + sizeof(connection_layer_status_)); + static_cast(reinterpret_cast(&is_mutual_contact_) - + reinterpret_cast(&session_id_)) + sizeof(is_mutual_contact_)); // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd) } @@ -8953,8 +10033,8 @@ referrer_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStri #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&attachments_info_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&connection_layer_status_) - - reinterpret_cast(&attachments_info_)) + sizeof(connection_layer_status_)); + 0, static_cast(reinterpret_cast(&is_mutual_contact_) - + reinterpret_cast(&attachments_info_)) + sizeof(is_mutual_contact_)); } SharingLog_SendAttachmentsEnd::~SharingLog_SendAttachmentsEnd() { @@ -9006,10 +10086,10 @@ void SharingLog_SendAttachmentsEnd::Clear() { reinterpret_cast(&duration_millis_) - reinterpret_cast(&session_id_)) + sizeof(duration_millis_)); } - if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x0000ff00u) { ::memset(&concurrent_connections_, 0, static_cast( - reinterpret_cast(&connection_layer_status_) - - reinterpret_cast(&concurrent_connections_)) + sizeof(connection_layer_status_)); + reinterpret_cast(&is_mutual_contact_) - + reinterpret_cast(&concurrent_connections_)) + sizeof(is_mutual_contact_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -9118,6 +10198,64 @@ const char* SharingLog_SendAttachmentsEnd::_InternalParse(const char* ptr, ::PRO } else goto handle_unusual; continue; + // optional int32 first_successful_transfer_date = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { + _Internal::set_has_first_successful_transfer_date(&has_bits); + first_successful_transfer_date_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 previous_successful_transfer_date = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { + _Internal::set_has_previous_successful_transfer_date(&has_bits); + previous_successful_transfer_date_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 lifetime_transfer_count = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 104)) { + _Internal::set_has_lifetime_transfer_count(&has_bits); + lifetime_transfer_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 connection_medium = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + _Internal::set_has_connection_medium(&has_bits); + connection_medium_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.proto.sharing.DataUsage data_usage = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::sharing::DataUsage_IsValid(val))) { + _internal_set_data_usage(static_cast<::location::nearby::proto::sharing::DataUsage>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool is_mutual_contact = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + _Internal::set_has_is_mutual_contact(&has_bits); + is_mutual_contact_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -9215,6 +10353,43 @@ uint8_t* SharingLog_SendAttachmentsEnd::_InternalSerialize( 10, this->_internal_connection_layer_status(), target); } + // optional int32 first_successful_transfer_date = 11; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(11, this->_internal_first_successful_transfer_date(), target); + } + + // optional int32 previous_successful_transfer_date = 12; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(12, this->_internal_previous_successful_transfer_date(), target); + } + + // optional int32 lifetime_transfer_count = 13; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(13, this->_internal_lifetime_transfer_count(), target); + } + + // optional int32 connection_medium = 14; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(14, this->_internal_connection_medium(), target); + } + + // optional .location.nearby.proto.sharing.DataUsage data_usage = 15; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 15, this->_internal_data_usage(), target); + } + + // optional bool is_mutual_contact = 16; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(16, this->_internal_is_mutual_contact(), 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); @@ -9281,7 +10456,7 @@ size_t SharingLog_SendAttachmentsEnd::ByteSizeLong() const { } } - if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x0000ff00u) { // optional int32 concurrent_connections = 5; if (cached_has_bits & 0x00000100u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_concurrent_connections()); @@ -9293,6 +10468,37 @@ size_t SharingLog_SendAttachmentsEnd::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_connection_layer_status()); } + // optional int32 first_successful_transfer_date = 11; + if (cached_has_bits & 0x00000400u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_first_successful_transfer_date()); + } + + // optional int32 previous_successful_transfer_date = 12; + if (cached_has_bits & 0x00000800u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_previous_successful_transfer_date()); + } + + // optional int32 lifetime_transfer_count = 13; + if (cached_has_bits & 0x00001000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_lifetime_transfer_count()); + } + + // optional int32 connection_medium = 14; + if (cached_has_bits & 0x00002000u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_connection_medium()); + } + + // optional .location.nearby.proto.sharing.DataUsage data_usage = 15; + if (cached_has_bits & 0x00004000u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_data_usage()); + } + + // optional bool is_mutual_contact = 16; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + 1; + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -9342,13 +10548,31 @@ void SharingLog_SendAttachmentsEnd::MergeFrom(const SharingLog_SendAttachmentsEn } _has_bits_[0] |= cached_has_bits; } - if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { concurrent_connections_ = from.concurrent_connections_; } if (cached_has_bits & 0x00000200u) { connection_layer_status_ = from.connection_layer_status_; } + if (cached_has_bits & 0x00000400u) { + first_successful_transfer_date_ = from.first_successful_transfer_date_; + } + if (cached_has_bits & 0x00000800u) { + previous_successful_transfer_date_ = from.previous_successful_transfer_date_; + } + if (cached_has_bits & 0x00001000u) { + lifetime_transfer_count_ = from.lifetime_transfer_count_; + } + if (cached_has_bits & 0x00002000u) { + connection_medium_ = from.connection_medium_; + } + if (cached_has_bits & 0x00004000u) { + data_usage_ = from.data_usage_; + } + if (cached_has_bits & 0x00008000u) { + is_mutual_contact_ = from.is_mutual_contact_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -9377,8 +10601,8 @@ void SharingLog_SendAttachmentsEnd::InternalSwap(SharingLog_SendAttachmentsEnd* &other->referrer_name_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SharingLog_SendAttachmentsEnd, connection_layer_status_) - + sizeof(SharingLog_SendAttachmentsEnd::connection_layer_status_) + PROTOBUF_FIELD_OFFSET(SharingLog_SendAttachmentsEnd, is_mutual_contact_) + + sizeof(SharingLog_SendAttachmentsEnd::is_mutual_contact_) - PROTOBUF_FIELD_OFFSET(SharingLog_SendAttachmentsEnd, attachments_info_)>( reinterpret_cast(&attachments_info_), reinterpret_cast(&other->attachments_info_)); @@ -9702,6 +10926,21 @@ class SharingLog_ReceiveAttachmentsEnd::_Internal { static void set_has_share_target_info(HasBits* has_bits) { (*has_bits)[0] |= 2u; } + static void set_has_first_successful_transfer_date(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_previous_successful_transfer_date(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_lifetime_transfer_count(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } + static void set_has_connection_medium(HasBits* has_bits) { + (*has_bits)[0] |= 256u; + } + static void set_has_data_usage(HasBits* has_bits) { + (*has_bits)[0] |= 512u; + } }; const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& @@ -9735,8 +10974,8 @@ SharingLog_ReceiveAttachmentsEnd::SharingLog_ReceiveAttachmentsEnd(const Sharing share_target_info_ = nullptr; } ::memcpy(&session_id_, &from.session_id_, - static_cast(reinterpret_cast(&status_) - - reinterpret_cast(&session_id_)) + sizeof(status_)); + static_cast(reinterpret_cast(&data_usage_) - + reinterpret_cast(&session_id_)) + sizeof(data_usage_)); // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd) } @@ -9747,8 +10986,8 @@ referrer_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStri #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&share_target_info_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&status_) - - reinterpret_cast(&share_target_info_)) + sizeof(status_)); + 0, static_cast(reinterpret_cast(&data_usage_) - + reinterpret_cast(&share_target_info_)) + sizeof(data_usage_)); } SharingLog_ReceiveAttachmentsEnd::~SharingLog_ReceiveAttachmentsEnd() { @@ -9790,10 +11029,15 @@ void SharingLog_ReceiveAttachmentsEnd::Clear() { share_target_info_->Clear(); } } - if (cached_has_bits & 0x0000001cu) { + if (cached_has_bits & 0x000000fcu) { ::memset(&session_id_, 0, static_cast( - reinterpret_cast(&status_) - - reinterpret_cast(&session_id_)) + sizeof(status_)); + reinterpret_cast(&lifetime_transfer_count_) - + reinterpret_cast(&session_id_)) + sizeof(lifetime_transfer_count_)); + } + if (cached_has_bits & 0x00000300u) { + ::memset(&connection_medium_, 0, static_cast( + reinterpret_cast(&data_usage_) - + reinterpret_cast(&connection_medium_)) + sizeof(data_usage_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -9854,6 +11098,55 @@ const char* SharingLog_ReceiveAttachmentsEnd::_InternalParse(const char* ptr, :: } else goto handle_unusual; continue; + // optional int32 first_successful_transfer_date = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_first_successful_transfer_date(&has_bits); + first_successful_transfer_date_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 previous_successful_transfer_date = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_previous_successful_transfer_date(&has_bits); + previous_successful_transfer_date_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 lifetime_transfer_count = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_lifetime_transfer_count(&has_bits); + lifetime_transfer_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 connection_medium = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + _Internal::set_has_connection_medium(&has_bits); + connection_medium_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.proto.sharing.DataUsage data_usage = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 120)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::proto::sharing::DataUsage_IsValid(val))) { + _internal_set_data_usage(static_cast<::location::nearby::proto::sharing::DataUsage>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(15, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -9918,6 +11211,37 @@ uint8_t* SharingLog_ReceiveAttachmentsEnd::_InternalSerialize( 5, _Internal::share_target_info(this), target, stream); } + // optional int32 first_successful_transfer_date = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_first_successful_transfer_date(), target); + } + + // optional int32 previous_successful_transfer_date = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_previous_successful_transfer_date(), target); + } + + // optional int32 lifetime_transfer_count = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(8, this->_internal_lifetime_transfer_count(), target); + } + + // optional int32 connection_medium = 14; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(14, this->_internal_connection_medium(), target); + } + + // optional .location.nearby.proto.sharing.DataUsage data_usage = 15; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 15, this->_internal_data_usage(), 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); @@ -9935,7 +11259,7 @@ size_t SharingLog_ReceiveAttachmentsEnd::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x000000ffu) { // optional string referrer_name = 4; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -9966,6 +11290,34 @@ size_t SharingLog_ReceiveAttachmentsEnd::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status()); } + // optional int32 first_successful_transfer_date = 6; + if (cached_has_bits & 0x00000020u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_first_successful_transfer_date()); + } + + // optional int32 previous_successful_transfer_date = 7; + if (cached_has_bits & 0x00000040u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_previous_successful_transfer_date()); + } + + // optional int32 lifetime_transfer_count = 8; + if (cached_has_bits & 0x00000080u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_lifetime_transfer_count()); + } + + } + if (cached_has_bits & 0x00000300u) { + // optional int32 connection_medium = 14; + if (cached_has_bits & 0x00000100u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_connection_medium()); + } + + // optional .location.nearby.proto.sharing.DataUsage data_usage = 15; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_data_usage()); + } + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); @@ -9988,7 +11340,7 @@ void SharingLog_ReceiveAttachmentsEnd::MergeFrom(const SharingLog_ReceiveAttachm (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { _internal_set_referrer_name(from._internal_referrer_name()); } @@ -10004,6 +11356,24 @@ void SharingLog_ReceiveAttachmentsEnd::MergeFrom(const SharingLog_ReceiveAttachm if (cached_has_bits & 0x00000010u) { status_ = from.status_; } + if (cached_has_bits & 0x00000020u) { + first_successful_transfer_date_ = from.first_successful_transfer_date_; + } + if (cached_has_bits & 0x00000040u) { + previous_successful_transfer_date_ = from.previous_successful_transfer_date_; + } + if (cached_has_bits & 0x00000080u) { + lifetime_transfer_count_ = from.lifetime_transfer_count_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x00000100u) { + connection_medium_ = from.connection_medium_; + } + if (cached_has_bits & 0x00000200u) { + data_usage_ = from.data_usage_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -10032,8 +11402,8 @@ void SharingLog_ReceiveAttachmentsEnd::InternalSwap(SharingLog_ReceiveAttachment &other->referrer_name_, rhs_arena ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SharingLog_ReceiveAttachmentsEnd, status_) - + sizeof(SharingLog_ReceiveAttachmentsEnd::status_) + PROTOBUF_FIELD_OFFSET(SharingLog_ReceiveAttachmentsEnd, data_usage_) + + sizeof(SharingLog_ReceiveAttachmentsEnd::data_usage_) - PROTOBUF_FIELD_OFFSET(SharingLog_ReceiveAttachmentsEnd, share_target_info_)>( reinterpret_cast(&share_target_info_), reinterpret_cast(&other->share_target_info_)); @@ -17077,6 +18447,12 @@ class SharingLog_ShareTargetInfo::_Internal { static void set_has_device_relationship(HasBits* has_bits) { (*has_bits)[0] |= 4u; } + static void set_has_has_matching_qr_code(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_is_external(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } }; SharingLog_ShareTargetInfo::SharingLog_ShareTargetInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, @@ -17093,16 +18469,16 @@ SharingLog_ShareTargetInfo::SharingLog_ShareTargetInfo(const SharingLog_ShareTar _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom(from._internal_metadata_); ::memcpy(&device_type_, &from.device_type_, - static_cast(reinterpret_cast(&device_relationship_) - - reinterpret_cast(&device_type_)) + sizeof(device_relationship_)); + static_cast(reinterpret_cast(&is_external_) - + reinterpret_cast(&device_type_)) + sizeof(is_external_)); // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo) } inline void SharingLog_ShareTargetInfo::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&device_type_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&device_relationship_) - - reinterpret_cast(&device_type_)) + sizeof(device_relationship_)); + 0, static_cast(reinterpret_cast(&is_external_) - + reinterpret_cast(&device_type_)) + sizeof(is_external_)); } SharingLog_ShareTargetInfo::~SharingLog_ShareTargetInfo() { @@ -17133,10 +18509,10 @@ void SharingLog_ShareTargetInfo::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x0000001fu) { ::memset(&device_type_, 0, static_cast( - reinterpret_cast(&device_relationship_) - - reinterpret_cast(&device_type_)) + sizeof(device_relationship_)); + reinterpret_cast(&is_external_) - + reinterpret_cast(&device_type_)) + sizeof(is_external_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -17188,6 +18564,24 @@ const char* SharingLog_ShareTargetInfo::_InternalParse(const char* ptr, ::PROTOB } else goto handle_unusual; continue; + // optional bool has_matching_qr_code = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_has_matching_qr_code(&has_bits); + has_matching_qr_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool is_external = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_is_external(&has_bits); + is_external_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -17240,6 +18634,18 @@ uint8_t* SharingLog_ShareTargetInfo::_InternalSerialize( 3, this->_internal_device_relationship(), target); } + // optional bool has_matching_qr_code = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_has_matching_qr_code(), target); + } + + // optional bool is_external = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_is_external(), 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); @@ -17257,7 +18663,7 @@ size_t SharingLog_ShareTargetInfo::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x0000001fu) { // optional .location.nearby.proto.sharing.DeviceType device_type = 1; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -17276,6 +18682,16 @@ size_t SharingLog_ShareTargetInfo::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_device_relationship()); } + // optional bool has_matching_qr_code = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + // optional bool is_external = 5; + if (cached_has_bits & 0x00000010u) { + 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(); @@ -17298,7 +18714,7 @@ void SharingLog_ShareTargetInfo::MergeFrom(const SharingLog_ShareTargetInfo& fro (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x0000001fu) { if (cached_has_bits & 0x00000001u) { device_type_ = from.device_type_; } @@ -17308,6 +18724,12 @@ void SharingLog_ShareTargetInfo::MergeFrom(const SharingLog_ShareTargetInfo& fro if (cached_has_bits & 0x00000004u) { device_relationship_ = from.device_relationship_; } + if (cached_has_bits & 0x00000008u) { + has_matching_qr_code_ = from.has_matching_qr_code_; + } + if (cached_has_bits & 0x00000010u) { + is_external_ = from.is_external_; + } _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); @@ -17329,8 +18751,8 @@ void SharingLog_ShareTargetInfo::InternalSwap(SharingLog_ShareTargetInfo* other) _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SharingLog_ShareTargetInfo, device_relationship_) - + sizeof(SharingLog_ShareTargetInfo::device_relationship_) + PROTOBUF_FIELD_OFFSET(SharingLog_ShareTargetInfo, is_external_) + + sizeof(SharingLog_ShareTargetInfo::is_external_) - PROTOBUF_FIELD_OFFSET(SharingLog_ShareTargetInfo, device_type_)>( reinterpret_cast(&device_type_), reinterpret_cast(&other->device_type_)); @@ -19211,6 +20633,589 @@ std::string SharingLog_StreamAttachment::GetTypeName() const { } +// =================================================================== + +class SharingLog_CloudAttachmentInfo::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_status(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_TextAttachment& text_attachment(const SharingLog_CloudAttachmentInfo* msg); + static const ::nearby::sharing::analytics::proto::SharingLog_FileAttachment& file_attachment(const SharingLog_CloudAttachmentInfo* msg); + static const ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment& wifi_credentials_attachment(const SharingLog_CloudAttachmentInfo* msg); + static const ::nearby::sharing::analytics::proto::SharingLog_AppAttachment& app_attachment(const SharingLog_CloudAttachmentInfo* msg); + static const ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment& stream_attachment(const SharingLog_CloudAttachmentInfo* msg); + static void set_has_transferred_bytes(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_duration_millis(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } +}; + +const ::nearby::sharing::analytics::proto::SharingLog_TextAttachment& +SharingLog_CloudAttachmentInfo::_Internal::text_attachment(const SharingLog_CloudAttachmentInfo* msg) { + return *msg->CloudAttachment_.text_attachment_; +} +const ::nearby::sharing::analytics::proto::SharingLog_FileAttachment& +SharingLog_CloudAttachmentInfo::_Internal::file_attachment(const SharingLog_CloudAttachmentInfo* msg) { + return *msg->CloudAttachment_.file_attachment_; +} +const ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment& +SharingLog_CloudAttachmentInfo::_Internal::wifi_credentials_attachment(const SharingLog_CloudAttachmentInfo* msg) { + return *msg->CloudAttachment_.wifi_credentials_attachment_; +} +const ::nearby::sharing::analytics::proto::SharingLog_AppAttachment& +SharingLog_CloudAttachmentInfo::_Internal::app_attachment(const SharingLog_CloudAttachmentInfo* msg) { + return *msg->CloudAttachment_.app_attachment_; +} +const ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment& +SharingLog_CloudAttachmentInfo::_Internal::stream_attachment(const SharingLog_CloudAttachmentInfo* msg) { + return *msg->CloudAttachment_.stream_attachment_; +} +void SharingLog_CloudAttachmentInfo::set_allocated_text_attachment(::nearby::sharing::analytics::proto::SharingLog_TextAttachment* text_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_CloudAttachment(); + if (text_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_TextAttachment>::GetOwningArena(text_attachment); + if (message_arena != submessage_arena) { + text_attachment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, text_attachment, submessage_arena); + } + set_has_text_attachment(); + CloudAttachment_.text_attachment_ = text_attachment; + } + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.text_attachment) +} +void SharingLog_CloudAttachmentInfo::set_allocated_file_attachment(::nearby::sharing::analytics::proto::SharingLog_FileAttachment* file_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_CloudAttachment(); + if (file_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_FileAttachment>::GetOwningArena(file_attachment); + if (message_arena != submessage_arena) { + file_attachment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, file_attachment, submessage_arena); + } + set_has_file_attachment(); + CloudAttachment_.file_attachment_ = file_attachment; + } + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.file_attachment) +} +void SharingLog_CloudAttachmentInfo::set_allocated_wifi_credentials_attachment(::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* wifi_credentials_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_CloudAttachment(); + if (wifi_credentials_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment>::GetOwningArena(wifi_credentials_attachment); + if (message_arena != submessage_arena) { + wifi_credentials_attachment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, wifi_credentials_attachment, submessage_arena); + } + set_has_wifi_credentials_attachment(); + CloudAttachment_.wifi_credentials_attachment_ = wifi_credentials_attachment; + } + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.wifi_credentials_attachment) +} +void SharingLog_CloudAttachmentInfo::set_allocated_app_attachment(::nearby::sharing::analytics::proto::SharingLog_AppAttachment* app_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_CloudAttachment(); + if (app_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_AppAttachment>::GetOwningArena(app_attachment); + if (message_arena != submessage_arena) { + app_attachment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, app_attachment, submessage_arena); + } + set_has_app_attachment(); + CloudAttachment_.app_attachment_ = app_attachment; + } + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.app_attachment) +} +void SharingLog_CloudAttachmentInfo::set_allocated_stream_attachment(::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* stream_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_CloudAttachment(); + if (stream_attachment) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_StreamAttachment>::GetOwningArena(stream_attachment); + if (message_arena != submessage_arena) { + stream_attachment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, stream_attachment, submessage_arena); + } + set_has_stream_attachment(); + CloudAttachment_.stream_attachment_ = stream_attachment; + } + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.stream_attachment) +} +SharingLog_CloudAttachmentInfo::SharingLog_CloudAttachmentInfo(::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:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) +} +SharingLog_CloudAttachmentInfo::SharingLog_CloudAttachmentInfo(const SharingLog_CloudAttachmentInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&status_, &from.status_, + static_cast(reinterpret_cast(&duration_millis_) - + reinterpret_cast(&status_)) + sizeof(duration_millis_)); + clear_has_CloudAttachment(); + switch (from.CloudAttachment_case()) { + case kTextAttachment: { + _internal_mutable_text_attachment()->::nearby::sharing::analytics::proto::SharingLog_TextAttachment::MergeFrom(from._internal_text_attachment()); + break; + } + case kFileAttachment: { + _internal_mutable_file_attachment()->::nearby::sharing::analytics::proto::SharingLog_FileAttachment::MergeFrom(from._internal_file_attachment()); + break; + } + case kWifiCredentialsAttachment: { + _internal_mutable_wifi_credentials_attachment()->::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment::MergeFrom(from._internal_wifi_credentials_attachment()); + break; + } + case kAppAttachment: { + _internal_mutable_app_attachment()->::nearby::sharing::analytics::proto::SharingLog_AppAttachment::MergeFrom(from._internal_app_attachment()); + break; + } + case kStreamAttachment: { + _internal_mutable_stream_attachment()->::nearby::sharing::analytics::proto::SharingLog_StreamAttachment::MergeFrom(from._internal_stream_attachment()); + break; + } + case CLOUDATTACHMENT_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) +} + +inline void SharingLog_CloudAttachmentInfo::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&status_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&duration_millis_) - + reinterpret_cast(&status_)) + sizeof(duration_millis_)); +clear_has_CloudAttachment(); +} + +SharingLog_CloudAttachmentInfo::~SharingLog_CloudAttachmentInfo() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_CloudAttachmentInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (has_CloudAttachment()) { + clear_CloudAttachment(); + } +} + +void SharingLog_CloudAttachmentInfo::ArenaDtor(void* object) { + SharingLog_CloudAttachmentInfo* _this = reinterpret_cast< SharingLog_CloudAttachmentInfo* >(object); + (void)_this; +} +void SharingLog_CloudAttachmentInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_CloudAttachmentInfo::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_CloudAttachmentInfo::clear_CloudAttachment() { +// @@protoc_insertion_point(one_of_clear_start:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) + switch (CloudAttachment_case()) { + case kTextAttachment: { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.text_attachment_; + } + break; + } + case kFileAttachment: { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.file_attachment_; + } + break; + } + case kWifiCredentialsAttachment: { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.wifi_credentials_attachment_; + } + break; + } + case kAppAttachment: { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.app_attachment_; + } + break; + } + case kStreamAttachment: { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.stream_attachment_; + } + break; + } + case CLOUDATTACHMENT_NOT_SET: { + break; + } + } + _oneof_case_[0] = CLOUDATTACHMENT_NOT_SET; +} + + +void SharingLog_CloudAttachmentInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) + 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) { + ::memset(&status_, 0, static_cast( + reinterpret_cast(&duration_millis_) - + reinterpret_cast(&status_)) + sizeof(duration_millis_)); + } + clear_CloudAttachment(); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_CloudAttachmentInfo::_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.proto.sharing.AttachmentTransmissionStatus status = 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::proto::sharing::AttachmentTransmissionStatus_IsValid(val))) { + _internal_set_status(static_cast<::location::nearby::proto::sharing::AttachmentTransmissionStatus>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // .nearby.sharing.analytics.proto.SharingLog.TextAttachment text_attachment = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_text_attachment(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .nearby.sharing.analytics.proto.SharingLog.FileAttachment file_attachment = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_file_attachment(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .nearby.sharing.analytics.proto.SharingLog.WifiCredentialsAttachment wifi_credentials_attachment = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_wifi_credentials_attachment(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .nearby.sharing.analytics.proto.SharingLog.AppAttachment app_attachment = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_app_attachment(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .nearby.sharing.analytics.proto.SharingLog.StreamAttachment stream_attachment = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_stream_attachment(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 transferred_bytes = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_transferred_bytes(&has_bits); + transferred_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 duration_millis = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_duration_millis(&has_bits); + duration_millis_ = ::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* SharingLog_CloudAttachmentInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.proto.sharing.AttachmentTransmissionStatus status = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_status(), target); + } + + switch (CloudAttachment_case()) { + case kTextAttachment: { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::text_attachment(this), target, stream); + break; + } + case kFileAttachment: { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::file_attachment(this), target, stream); + break; + } + case kWifiCredentialsAttachment: { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::wifi_credentials_attachment(this), target, stream); + break; + } + case kAppAttachment: { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::app_attachment(this), target, stream); + break; + } + case kStreamAttachment: { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::stream_attachment(this), target, stream); + break; + } + default: ; + } + // optional int64 transferred_bytes = 7; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_transferred_bytes(), target); + } + + // optional int64 duration_millis = 8; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(8, this->_internal_duration_millis(), 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:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) + return target; +} + +size_t SharingLog_CloudAttachmentInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) + 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 .location.nearby.proto.sharing.AttachmentTransmissionStatus status = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status()); + } + + // optional int64 transferred_bytes = 7; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_transferred_bytes()); + } + + // optional int64 duration_millis = 8; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis()); + } + + } + switch (CloudAttachment_case()) { + // .nearby.sharing.analytics.proto.SharingLog.TextAttachment text_attachment = 2; + case kTextAttachment: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *CloudAttachment_.text_attachment_); + break; + } + // .nearby.sharing.analytics.proto.SharingLog.FileAttachment file_attachment = 3; + case kFileAttachment: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *CloudAttachment_.file_attachment_); + break; + } + // .nearby.sharing.analytics.proto.SharingLog.WifiCredentialsAttachment wifi_credentials_attachment = 4; + case kWifiCredentialsAttachment: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *CloudAttachment_.wifi_credentials_attachment_); + break; + } + // .nearby.sharing.analytics.proto.SharingLog.AppAttachment app_attachment = 5; + case kAppAttachment: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *CloudAttachment_.app_attachment_); + break; + } + // .nearby.sharing.analytics.proto.SharingLog.StreamAttachment stream_attachment = 6; + case kStreamAttachment: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *CloudAttachment_.stream_attachment_); + break; + } + case CLOUDATTACHMENT_NOT_SET: { + break; + } + } + 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 SharingLog_CloudAttachmentInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_CloudAttachmentInfo::MergeFrom(const SharingLog_CloudAttachmentInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) + 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) { + status_ = from.status_; + } + if (cached_has_bits & 0x00000002u) { + transferred_bytes_ = from.transferred_bytes_; + } + if (cached_has_bits & 0x00000004u) { + duration_millis_ = from.duration_millis_; + } + _has_bits_[0] |= cached_has_bits; + } + switch (from.CloudAttachment_case()) { + case kTextAttachment: { + _internal_mutable_text_attachment()->::nearby::sharing::analytics::proto::SharingLog_TextAttachment::MergeFrom(from._internal_text_attachment()); + break; + } + case kFileAttachment: { + _internal_mutable_file_attachment()->::nearby::sharing::analytics::proto::SharingLog_FileAttachment::MergeFrom(from._internal_file_attachment()); + break; + } + case kWifiCredentialsAttachment: { + _internal_mutable_wifi_credentials_attachment()->::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment::MergeFrom(from._internal_wifi_credentials_attachment()); + break; + } + case kAppAttachment: { + _internal_mutable_app_attachment()->::nearby::sharing::analytics::proto::SharingLog_AppAttachment::MergeFrom(from._internal_app_attachment()); + break; + } + case kStreamAttachment: { + _internal_mutable_stream_attachment()->::nearby::sharing::analytics::proto::SharingLog_StreamAttachment::MergeFrom(from._internal_stream_attachment()); + break; + } + case CLOUDATTACHMENT_NOT_SET: { + break; + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_CloudAttachmentInfo::CopyFrom(const SharingLog_CloudAttachmentInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_CloudAttachmentInfo::IsInitialized() const { + return true; +} + +void SharingLog_CloudAttachmentInfo::InternalSwap(SharingLog_CloudAttachmentInfo* 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(SharingLog_CloudAttachmentInfo, duration_millis_) + + sizeof(SharingLog_CloudAttachmentInfo::duration_millis_) + - PROTOBUF_FIELD_OFFSET(SharingLog_CloudAttachmentInfo, status_)>( + reinterpret_cast(&status_), + reinterpret_cast(&other->status_)); + swap(CloudAttachment_, other->CloudAttachment_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +std::string SharingLog_CloudAttachmentInfo::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo"; +} + + // =================================================================== class SharingLog_AppCrash::_Internal { @@ -19412,6 +21417,9 @@ class SharingLog_SetupWizard::_Internal { static void set_has_visibility(HasBits* has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_previous_visibility(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } }; SharingLog_SetupWizard::SharingLog_SetupWizard(::PROTOBUF_NAMESPACE_ID::Arena* arena, @@ -19427,12 +21435,17 @@ SharingLog_SetupWizard::SharingLog_SetupWizard(const SharingLog_SetupWizard& fro : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { _internal_metadata_.MergeFrom(from._internal_metadata_); - visibility_ = from.visibility_; + ::memcpy(&visibility_, &from.visibility_, + static_cast(reinterpret_cast(&previous_visibility_) - + reinterpret_cast(&visibility_)) + sizeof(previous_visibility_)); // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.SetupWizard) } inline void SharingLog_SetupWizard::SharedCtor() { -visibility_ = 0; +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&visibility_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&previous_visibility_) - + reinterpret_cast(&visibility_)) + sizeof(previous_visibility_)); } SharingLog_SetupWizard::~SharingLog_SetupWizard() { @@ -19462,7 +21475,12 @@ void SharingLog_SetupWizard::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - visibility_ = 0; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + ::memset(&visibility_, 0, static_cast( + reinterpret_cast(&previous_visibility_) - + reinterpret_cast(&visibility_)) + sizeof(previous_visibility_)); + } _has_bits_.Clear(); _internal_metadata_.Clear(); } @@ -19487,6 +21505,19 @@ const char* SharingLog_SetupWizard::_InternalParse(const char* ptr, ::PROTOBUF_N } else goto handle_unusual; continue; + // optional .location.nearby.proto.sharing.Visibility previous_visibility = 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::proto::sharing::Visibility_IsValid(val))) { + _internal_set_previous_visibility(static_cast<::location::nearby::proto::sharing::Visibility>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -19525,6 +21556,13 @@ uint8_t* SharingLog_SetupWizard::_InternalSerialize( 1, this->_internal_visibility(), target); } + // optional .location.nearby.proto.sharing.Visibility previous_visibility = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_previous_visibility(), 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); @@ -19541,13 +21579,21 @@ size_t SharingLog_SetupWizard::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // optional .location.nearby.proto.sharing.Visibility visibility = 1; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_visibility()); - } + if (cached_has_bits & 0x00000003u) { + // optional .location.nearby.proto.sharing.Visibility visibility = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_visibility()); + } + // optional .location.nearby.proto.sharing.Visibility previous_visibility = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_previous_visibility()); + } + + } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); } @@ -19568,8 +21614,15 @@ void SharingLog_SetupWizard::MergeFrom(const SharingLog_SetupWizard& from) { uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from._internal_has_visibility()) { - _internal_set_visibility(from._internal_visibility()); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + visibility_ = from.visibility_; + } + if (cached_has_bits & 0x00000002u) { + previous_visibility_ = from.previous_visibility_; + } + _has_bits_[0] |= cached_has_bits; } _internal_metadata_.MergeFrom(from._internal_metadata_); } @@ -19589,7 +21642,12 @@ void SharingLog_SetupWizard::InternalSwap(SharingLog_SetupWizard* other) { using std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_has_bits_[0], other->_has_bits_[0]); - swap(visibility_, other->visibility_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SharingLog_SetupWizard, previous_visibility_) + + sizeof(SharingLog_SetupWizard::previous_visibility_) + - PROTOBUF_FIELD_OFFSET(SharingLog_SetupWizard, visibility_)>( + reinterpret_cast(&visibility_), + reinterpret_cast(&other->visibility_)); } std::string SharingLog_SetupWizard::GetTypeName() const { @@ -19983,13 +22041,3484 @@ std::string SharingLog_SendDesktopTransferEvent::GetTypeName() const { } +// =================================================================== + +class SharingLog_ShowWaitingForAccept::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_button_status(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SharingLog_ShowWaitingForAccept::SharingLog_ShowWaitingForAccept(::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:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) +} +SharingLog_ShowWaitingForAccept::SharingLog_ShowWaitingForAccept(const SharingLog_ShowWaitingForAccept& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + button_status_ = from.button_status_; + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) +} + +inline void SharingLog_ShowWaitingForAccept::SharedCtor() { +button_status_ = 0; +} + +SharingLog_ShowWaitingForAccept::~SharingLog_ShowWaitingForAccept() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_ShowWaitingForAccept::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SharingLog_ShowWaitingForAccept::ArenaDtor(void* object) { + SharingLog_ShowWaitingForAccept* _this = reinterpret_cast< SharingLog_ShowWaitingForAccept* >(object); + (void)_this; +} +void SharingLog_ShowWaitingForAccept::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_ShowWaitingForAccept::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_ShowWaitingForAccept::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + button_status_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_ShowWaitingForAccept::_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.proto.sharing.ButtonStatus button_status = 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::proto::sharing::ButtonStatus_IsValid(val))) { + _internal_set_button_status(static_cast<::location::nearby::proto::sharing::ButtonStatus>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, 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* SharingLog_ShowWaitingForAccept::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.proto.sharing.ButtonStatus button_status = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_button_status(), 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:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) + return target; +} + +size_t SharingLog_ShowWaitingForAccept::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) + 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 .location.nearby.proto.sharing.ButtonStatus button_status = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_button_status()); + } + + 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 SharingLog_ShowWaitingForAccept::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_ShowWaitingForAccept::MergeFrom(const SharingLog_ShowWaitingForAccept& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_button_status()) { + _internal_set_button_status(from._internal_button_status()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_ShowWaitingForAccept::CopyFrom(const SharingLog_ShowWaitingForAccept& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_ShowWaitingForAccept::IsInitialized() const { + return true; +} + +void SharingLog_ShowWaitingForAccept::InternalSwap(SharingLog_ShowWaitingForAccept* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(button_status_, other->button_status_); +} + +std::string SharingLog_ShowWaitingForAccept::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept"; +} + + +// =================================================================== + +class SharingLog_HighQualityMediumSetup::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& share_target_info(const SharingLog_HighQualityMediumSetup* msg); + static void set_has_share_target_info(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_session_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_duration_millis(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_is_timeout(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_original_quality(HasBits* has_bits) { + (*has_bits)[0] |= 16u; + } + static void set_has_connection_medium(HasBits* has_bits) { + (*has_bits)[0] |= 32u; + } + static void set_has_connection_mode(HasBits* has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_instant_connection_result(HasBits* has_bits) { + (*has_bits)[0] |= 128u; + } +}; + +const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& +SharingLog_HighQualityMediumSetup::_Internal::share_target_info(const SharingLog_HighQualityMediumSetup* msg) { + return *msg->share_target_info_; +} +SharingLog_HighQualityMediumSetup::SharingLog_HighQualityMediumSetup(::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:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) +} +SharingLog_HighQualityMediumSetup::SharingLog_HighQualityMediumSetup(const SharingLog_HighQualityMediumSetup& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_share_target_info()) { + share_target_info_ = new ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo(*from.share_target_info_); + } else { + share_target_info_ = nullptr; + } + ::memcpy(&session_id_, &from.session_id_, + static_cast(reinterpret_cast(&instant_connection_result_) - + reinterpret_cast(&session_id_)) + sizeof(instant_connection_result_)); + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) +} + +inline void SharingLog_HighQualityMediumSetup::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&share_target_info_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&instant_connection_result_) - + reinterpret_cast(&share_target_info_)) + sizeof(instant_connection_result_)); +} + +SharingLog_HighQualityMediumSetup::~SharingLog_HighQualityMediumSetup() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_HighQualityMediumSetup::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete share_target_info_; +} + +void SharingLog_HighQualityMediumSetup::ArenaDtor(void* object) { + SharingLog_HighQualityMediumSetup* _this = reinterpret_cast< SharingLog_HighQualityMediumSetup* >(object); + (void)_this; +} +void SharingLog_HighQualityMediumSetup::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_HighQualityMediumSetup::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_HighQualityMediumSetup::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) + 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(share_target_info_ != nullptr); + share_target_info_->Clear(); + } + if (cached_has_bits & 0x000000feu) { + ::memset(&session_id_, 0, static_cast( + reinterpret_cast(&instant_connection_result_) - + reinterpret_cast(&session_id_)) + sizeof(instant_connection_result_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_HighQualityMediumSetup::_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 .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_share_target_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 session_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_session_id(&has_bits); + session_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 duration_millis = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_duration_millis(&has_bits); + duration_millis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bool is_timeout = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_is_timeout(&has_bits); + is_timeout_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 original_quality = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_original_quality(&has_bits); + original_quality_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 connection_medium = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + _Internal::set_has_connection_medium(&has_bits); + connection_medium_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 connection_mode = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { + _Internal::set_has_connection_mode(&has_bits); + connection_mode_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 instant_connection_result = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + _Internal::set_has_instant_connection_result(&has_bits); + instant_connection_result_ = ::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* SharingLog_HighQualityMediumSetup::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::share_target_info(this), target, stream); + } + + // optional int64 session_id = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_session_id(), target); + } + + // optional int64 duration_millis = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_duration_millis(), target); + } + + // optional bool is_timeout = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_is_timeout(), target); + } + + // optional int32 original_quality = 5; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_original_quality(), target); + } + + // optional int32 connection_medium = 6; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_connection_medium(), target); + } + + // optional int32 connection_mode = 7; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_connection_mode(), target); + } + + // optional int32 instant_connection_result = 8; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(8, this->_internal_instant_connection_result(), 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:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) + return target; +} + +size_t SharingLog_HighQualityMediumSetup::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) + 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 .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *share_target_info_); + } + + // optional int64 session_id = 2; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_session_id()); + } + + // optional int64 duration_millis = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis()); + } + + // optional bool is_timeout = 4; + if (cached_has_bits & 0x00000008u) { + total_size += 1 + 1; + } + + // optional int32 original_quality = 5; + if (cached_has_bits & 0x00000010u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_original_quality()); + } + + // optional int32 connection_medium = 6; + if (cached_has_bits & 0x00000020u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_connection_medium()); + } + + // optional int32 connection_mode = 7; + if (cached_has_bits & 0x00000040u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_connection_mode()); + } + + // optional int32 instant_connection_result = 8; + if (cached_has_bits & 0x00000080u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_instant_connection_result()); + } + + } + 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 SharingLog_HighQualityMediumSetup::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_HighQualityMediumSetup::MergeFrom(const SharingLog_HighQualityMediumSetup& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) + 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_share_target_info()->::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo::MergeFrom(from._internal_share_target_info()); + } + if (cached_has_bits & 0x00000002u) { + session_id_ = from.session_id_; + } + if (cached_has_bits & 0x00000004u) { + duration_millis_ = from.duration_millis_; + } + if (cached_has_bits & 0x00000008u) { + is_timeout_ = from.is_timeout_; + } + if (cached_has_bits & 0x00000010u) { + original_quality_ = from.original_quality_; + } + if (cached_has_bits & 0x00000020u) { + connection_medium_ = from.connection_medium_; + } + if (cached_has_bits & 0x00000040u) { + connection_mode_ = from.connection_mode_; + } + if (cached_has_bits & 0x00000080u) { + instant_connection_result_ = from.instant_connection_result_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_HighQualityMediumSetup::CopyFrom(const SharingLog_HighQualityMediumSetup& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_HighQualityMediumSetup::IsInitialized() const { + return true; +} + +void SharingLog_HighQualityMediumSetup::InternalSwap(SharingLog_HighQualityMediumSetup* 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(SharingLog_HighQualityMediumSetup, instant_connection_result_) + + sizeof(SharingLog_HighQualityMediumSetup::instant_connection_result_) + - PROTOBUF_FIELD_OFFSET(SharingLog_HighQualityMediumSetup, share_target_info_)>( + reinterpret_cast(&share_target_info_), + reinterpret_cast(&other->share_target_info_)); +} + +std::string SharingLog_HighQualityMediumSetup::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup"; +} + + +// =================================================================== + +class SharingLog_RpcCallStatus::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_direction(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_rpc_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_error_code(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_latency_millis(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } +}; + +SharingLog_RpcCallStatus::SharingLog_RpcCallStatus(::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:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) +} +SharingLog_RpcCallStatus::SharingLog_RpcCallStatus(const SharingLog_RpcCallStatus& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + rpc_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + rpc_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_rpc_name()) { + rpc_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_rpc_name(), + GetArenaForAllocation()); + } + ::memcpy(&direction_, &from.direction_, + static_cast(reinterpret_cast(&latency_millis_) - + reinterpret_cast(&direction_)) + sizeof(latency_millis_)); + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) +} + +inline void SharingLog_RpcCallStatus::SharedCtor() { +rpc_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + rpc_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&direction_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&latency_millis_) - + reinterpret_cast(&direction_)) + sizeof(latency_millis_)); +} + +SharingLog_RpcCallStatus::~SharingLog_RpcCallStatus() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_RpcCallStatus::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + rpc_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SharingLog_RpcCallStatus::ArenaDtor(void* object) { + SharingLog_RpcCallStatus* _this = reinterpret_cast< SharingLog_RpcCallStatus* >(object); + (void)_this; +} +void SharingLog_RpcCallStatus::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_RpcCallStatus::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_RpcCallStatus::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) + 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) { + rpc_name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x0000000eu) { + ::memset(&direction_, 0, static_cast( + reinterpret_cast(&latency_millis_) - + reinterpret_cast(&direction_)) + sizeof(latency_millis_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_RpcCallStatus::_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 .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.RpcDirection direction = 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(::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection_IsValid(val))) { + _internal_set_direction(static_cast<::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string rpc_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_rpc_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 error_code = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_error_code(&has_bits); + error_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 latency_millis = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + _Internal::set_has_latency_millis(&has_bits); + latency_millis_ = ::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* SharingLog_RpcCallStatus::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.RpcDirection direction = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_direction(), target); + } + + // optional string rpc_name = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 2, this->_internal_rpc_name(), target); + } + + // optional int32 error_code = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_error_code(), target); + } + + // optional int64 latency_millis = 4; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_latency_millis(), 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:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) + return target; +} + +size_t SharingLog_RpcCallStatus::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) + 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 string rpc_name = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_rpc_name()); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.RpcDirection direction = 1; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction()); + } + + // optional int32 error_code = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_error_code()); + } + + // optional int64 latency_millis = 4; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_latency_millis()); + } + + } + 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 SharingLog_RpcCallStatus::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_RpcCallStatus::MergeFrom(const SharingLog_RpcCallStatus& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) + 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_set_rpc_name(from._internal_rpc_name()); + } + if (cached_has_bits & 0x00000002u) { + direction_ = from.direction_; + } + if (cached_has_bits & 0x00000004u) { + error_code_ = from.error_code_; + } + if (cached_has_bits & 0x00000008u) { + latency_millis_ = from.latency_millis_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_RpcCallStatus::CopyFrom(const SharingLog_RpcCallStatus& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_RpcCallStatus::IsInitialized() const { + return true; +} + +void SharingLog_RpcCallStatus::InternalSwap(SharingLog_RpcCallStatus* 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(), + &rpc_name_, lhs_arena, + &other->rpc_name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SharingLog_RpcCallStatus, latency_millis_) + + sizeof(SharingLog_RpcCallStatus::latency_millis_) + - PROTOBUF_FIELD_OFFSET(SharingLog_RpcCallStatus, direction_)>( + reinterpret_cast(&direction_), + reinterpret_cast(&other->direction_)); +} + +std::string SharingLog_RpcCallStatus::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.RpcCallStatus"; +} + + +// =================================================================== + +class SharingLog_StartQrCodeSession::_Internal { + public: +}; + +SharingLog_StartQrCodeSession::SharingLog_StartQrCodeSession(::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:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) +} +SharingLog_StartQrCodeSession::SharingLog_StartQrCodeSession(const SharingLog_StartQrCodeSession& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite() { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) +} + +inline void SharingLog_StartQrCodeSession::SharedCtor() { +} + +SharingLog_StartQrCodeSession::~SharingLog_StartQrCodeSession() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_StartQrCodeSession::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SharingLog_StartQrCodeSession::ArenaDtor(void* object) { + SharingLog_StartQrCodeSession* _this = reinterpret_cast< SharingLog_StartQrCodeSession* >(object); + (void)_this; +} +void SharingLog_StartQrCodeSession::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_StartQrCodeSession::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_StartQrCodeSession::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +const char* SharingLog_StartQrCodeSession::_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* SharingLog_StartQrCodeSession::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) + 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:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) + return target; +} + +size_t SharingLog_StartQrCodeSession::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) + 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 SharingLog_StartQrCodeSession::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_StartQrCodeSession::MergeFrom(const SharingLog_StartQrCodeSession& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_StartQrCodeSession::CopyFrom(const SharingLog_StartQrCodeSession& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_StartQrCodeSession::IsInitialized() const { + return true; +} + +void SharingLog_StartQrCodeSession::InternalSwap(SharingLog_StartQrCodeSession* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +std::string SharingLog_StartQrCodeSession::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession"; +} + + +// =================================================================== + +class SharingLog_QrCodeOpenedInWebClient::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_client_platform(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_is_retry(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +SharingLog_QrCodeOpenedInWebClient::SharingLog_QrCodeOpenedInWebClient(::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:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) +} +SharingLog_QrCodeOpenedInWebClient::SharingLog_QrCodeOpenedInWebClient(const SharingLog_QrCodeOpenedInWebClient& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&client_platform_, &from.client_platform_, + static_cast(reinterpret_cast(&is_retry_) - + reinterpret_cast(&client_platform_)) + sizeof(is_retry_)); + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) +} + +inline void SharingLog_QrCodeOpenedInWebClient::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&client_platform_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&is_retry_) - + reinterpret_cast(&client_platform_)) + sizeof(is_retry_)); +} + +SharingLog_QrCodeOpenedInWebClient::~SharingLog_QrCodeOpenedInWebClient() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_QrCodeOpenedInWebClient::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SharingLog_QrCodeOpenedInWebClient::ArenaDtor(void* object) { + SharingLog_QrCodeOpenedInWebClient* _this = reinterpret_cast< SharingLog_QrCodeOpenedInWebClient* >(object); + (void)_this; +} +void SharingLog_QrCodeOpenedInWebClient::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_QrCodeOpenedInWebClient::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_QrCodeOpenedInWebClient::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) + 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(&client_platform_, 0, static_cast( + reinterpret_cast(&is_retry_) - + reinterpret_cast(&client_platform_)) + sizeof(is_retry_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_QrCodeOpenedInWebClient::_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 .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient.ClientPlatform client_platform = 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(::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform_IsValid(val))) { + _internal_set_client_platform(static_cast<::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional bool is_retry = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_is_retry(&has_bits); + is_retry_ = ::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* SharingLog_QrCodeOpenedInWebClient::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient.ClientPlatform client_platform = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_client_platform(), target); + } + + // optional bool is_retry = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_is_retry(), 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:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) + return target; +} + +size_t SharingLog_QrCodeOpenedInWebClient::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) + 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 .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient.ClientPlatform client_platform = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_client_platform()); + } + + // optional bool is_retry = 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 SharingLog_QrCodeOpenedInWebClient::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_QrCodeOpenedInWebClient::MergeFrom(const SharingLog_QrCodeOpenedInWebClient& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) + 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) { + client_platform_ = from.client_platform_; + } + if (cached_has_bits & 0x00000002u) { + is_retry_ = from.is_retry_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_QrCodeOpenedInWebClient::CopyFrom(const SharingLog_QrCodeOpenedInWebClient& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_QrCodeOpenedInWebClient::IsInitialized() const { + return true; +} + +void SharingLog_QrCodeOpenedInWebClient::InternalSwap(SharingLog_QrCodeOpenedInWebClient* 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(SharingLog_QrCodeOpenedInWebClient, is_retry_) + + sizeof(SharingLog_QrCodeOpenedInWebClient::is_retry_) + - PROTOBUF_FIELD_OFFSET(SharingLog_QrCodeOpenedInWebClient, client_platform_)>( + reinterpret_cast(&client_platform_), + reinterpret_cast(&other->client_platform_)); +} + +std::string SharingLog_QrCodeOpenedInWebClient::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient"; +} + + +// =================================================================== + +class SharingLog_HatsJointEvent::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_flow_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_hats_session_id(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SharingLog_HatsJointEvent::SharingLog_HatsJointEvent(::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:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) +} +SharingLog_HatsJointEvent::SharingLog_HatsJointEvent(const SharingLog_HatsJointEvent& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + hats_session_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + hats_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_hats_session_id()) { + hats_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_hats_session_id(), + GetArenaForAllocation()); + } + flow_id_ = from.flow_id_; + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) +} + +inline void SharingLog_HatsJointEvent::SharedCtor() { +hats_session_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + hats_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +flow_id_ = int64_t{0}; +} + +SharingLog_HatsJointEvent::~SharingLog_HatsJointEvent() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_HatsJointEvent::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + hats_session_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SharingLog_HatsJointEvent::ArenaDtor(void* object) { + SharingLog_HatsJointEvent* _this = reinterpret_cast< SharingLog_HatsJointEvent* >(object); + (void)_this; +} +void SharingLog_HatsJointEvent::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_HatsJointEvent::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_HatsJointEvent::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) + 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) { + hats_session_id_.ClearNonDefaultToEmpty(); + } + flow_id_ = int64_t{0}; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_HatsJointEvent::_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 flow_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_flow_id(&has_bits); + flow_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string hats_session_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_hats_session_id(); + 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* SharingLog_HatsJointEvent::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int64 flow_id = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_flow_id(), target); + } + + // optional string hats_session_id = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 2, this->_internal_hats_session_id(), 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:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) + return target; +} + +size_t SharingLog_HatsJointEvent::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) + 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 hats_session_id = 2; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_hats_session_id()); + } + + // optional int64 flow_id = 1; + if (cached_has_bits & 0x00000002u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_flow_id()); + } + + } + 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 SharingLog_HatsJointEvent::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_HatsJointEvent::MergeFrom(const SharingLog_HatsJointEvent& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) + 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_hats_session_id(from._internal_hats_session_id()); + } + if (cached_has_bits & 0x00000002u) { + flow_id_ = from.flow_id_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_HatsJointEvent::CopyFrom(const SharingLog_HatsJointEvent& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_HatsJointEvent::IsInitialized() const { + return true; +} + +void SharingLog_HatsJointEvent::InternalSwap(SharingLog_HatsJointEvent* 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(), + &hats_session_id_, lhs_arena, + &other->hats_session_id_, rhs_arena + ); + swap(flow_id_, other->flow_id_); +} + +std::string SharingLog_HatsJointEvent::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.HatsJointEvent"; +} + + +// =================================================================== + +class SharingLog_ReceivePreviews::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_num_previews(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SharingLog_ReceivePreviews::SharingLog_ReceivePreviews(::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:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) +} +SharingLog_ReceivePreviews::SharingLog_ReceivePreviews(const SharingLog_ReceivePreviews& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + num_previews_ = from.num_previews_; + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) +} + +inline void SharingLog_ReceivePreviews::SharedCtor() { +num_previews_ = 0; +} + +SharingLog_ReceivePreviews::~SharingLog_ReceivePreviews() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_ReceivePreviews::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SharingLog_ReceivePreviews::ArenaDtor(void* object) { + SharingLog_ReceivePreviews* _this = reinterpret_cast< SharingLog_ReceivePreviews* >(object); + (void)_this; +} +void SharingLog_ReceivePreviews::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_ReceivePreviews::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_ReceivePreviews::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + num_previews_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_ReceivePreviews::_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 num_previews = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_num_previews(&has_bits); + num_previews_ = ::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* SharingLog_ReceivePreviews::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 num_previews = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_num_previews(), 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:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) + return target; +} + +size_t SharingLog_ReceivePreviews::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) + 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 int32 num_previews = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_previews()); + } + + 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 SharingLog_ReceivePreviews::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_ReceivePreviews::MergeFrom(const SharingLog_ReceivePreviews& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_num_previews()) { + _internal_set_num_previews(from._internal_num_previews()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_ReceivePreviews::CopyFrom(const SharingLog_ReceivePreviews& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_ReceivePreviews::IsInitialized() const { + return true; +} + +void SharingLog_ReceivePreviews::InternalSwap(SharingLog_ReceivePreviews* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(num_previews_, other->num_previews_); +} + +std::string SharingLog_ReceivePreviews::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.ReceivePreviews"; +} + + +// =================================================================== + +class SharingLog_CloudCreateSharingRequest::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& attachments_info(const SharingLog_CloudCreateSharingRequest* msg); + static void set_has_attachments_info(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_result(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& +SharingLog_CloudCreateSharingRequest::_Internal::attachments_info(const SharingLog_CloudCreateSharingRequest* msg) { + return *msg->attachments_info_; +} +SharingLog_CloudCreateSharingRequest::SharingLog_CloudCreateSharingRequest(::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:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) +} +SharingLog_CloudCreateSharingRequest::SharingLog_CloudCreateSharingRequest(const SharingLog_CloudCreateSharingRequest& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_attachments_info()) { + attachments_info_ = new ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo(*from.attachments_info_); + } else { + attachments_info_ = nullptr; + } + result_ = from.result_; + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) +} + +inline void SharingLog_CloudCreateSharingRequest::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&attachments_info_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&result_) - + reinterpret_cast(&attachments_info_)) + sizeof(result_)); +} + +SharingLog_CloudCreateSharingRequest::~SharingLog_CloudCreateSharingRequest() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_CloudCreateSharingRequest::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete attachments_info_; +} + +void SharingLog_CloudCreateSharingRequest::ArenaDtor(void* object) { + SharingLog_CloudCreateSharingRequest* _this = reinterpret_cast< SharingLog_CloudCreateSharingRequest* >(object); + (void)_this; +} +void SharingLog_CloudCreateSharingRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_CloudCreateSharingRequest::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_CloudCreateSharingRequest::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) + 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(attachments_info_ != nullptr); + attachments_info_->Clear(); + } + result_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_CloudCreateSharingRequest::_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 .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_attachments_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.proto.sharing.CloudCreateSharingResult result = 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::proto::sharing::CloudCreateSharingResult_IsValid(val))) { + _internal_set_result(static_cast<::location::nearby::proto::sharing::CloudCreateSharingResult>(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* SharingLog_CloudCreateSharingRequest::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::attachments_info(this), target, stream); + } + + // optional .location.nearby.proto.sharing.CloudCreateSharingResult result = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_result(), 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:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) + return target; +} + +size_t SharingLog_CloudCreateSharingRequest::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) + 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 .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *attachments_info_); + } + + // optional .location.nearby.proto.sharing.CloudCreateSharingResult result = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_result()); + } + + } + 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 SharingLog_CloudCreateSharingRequest::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_CloudCreateSharingRequest::MergeFrom(const SharingLog_CloudCreateSharingRequest& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) + 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_attachments_info()->::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo::MergeFrom(from._internal_attachments_info()); + } + if (cached_has_bits & 0x00000002u) { + result_ = from.result_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_CloudCreateSharingRequest::CopyFrom(const SharingLog_CloudCreateSharingRequest& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_CloudCreateSharingRequest::IsInitialized() const { + return true; +} + +void SharingLog_CloudCreateSharingRequest::InternalSwap(SharingLog_CloudCreateSharingRequest* 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(SharingLog_CloudCreateSharingRequest, result_) + + sizeof(SharingLog_CloudCreateSharingRequest::result_) + - PROTOBUF_FIELD_OFFSET(SharingLog_CloudCreateSharingRequest, attachments_info_)>( + reinterpret_cast(&attachments_info_), + reinterpret_cast(&other->attachments_info_)); +} + +std::string SharingLog_CloudCreateSharingRequest::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest"; +} + + +// =================================================================== + +class SharingLog_CloudRegisterReceiver::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_result(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SharingLog_CloudRegisterReceiver::SharingLog_CloudRegisterReceiver(::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:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) +} +SharingLog_CloudRegisterReceiver::SharingLog_CloudRegisterReceiver(const SharingLog_CloudRegisterReceiver& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + result_ = from.result_; + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) +} + +inline void SharingLog_CloudRegisterReceiver::SharedCtor() { +result_ = 0; +} + +SharingLog_CloudRegisterReceiver::~SharingLog_CloudRegisterReceiver() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_CloudRegisterReceiver::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SharingLog_CloudRegisterReceiver::ArenaDtor(void* object) { + SharingLog_CloudRegisterReceiver* _this = reinterpret_cast< SharingLog_CloudRegisterReceiver* >(object); + (void)_this; +} +void SharingLog_CloudRegisterReceiver::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_CloudRegisterReceiver::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_CloudRegisterReceiver::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + result_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_CloudRegisterReceiver::_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.proto.sharing.CloudRegisterReceiverResult result = 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::proto::sharing::CloudRegisterReceiverResult_IsValid(val))) { + _internal_set_result(static_cast<::location::nearby::proto::sharing::CloudRegisterReceiverResult>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, 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* SharingLog_CloudRegisterReceiver::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.proto.sharing.CloudRegisterReceiverResult result = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_result(), 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:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) + return target; +} + +size_t SharingLog_CloudRegisterReceiver::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) + 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 .location.nearby.proto.sharing.CloudRegisterReceiverResult result = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_result()); + } + + 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 SharingLog_CloudRegisterReceiver::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_CloudRegisterReceiver::MergeFrom(const SharingLog_CloudRegisterReceiver& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_result()) { + _internal_set_result(from._internal_result()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_CloudRegisterReceiver::CopyFrom(const SharingLog_CloudRegisterReceiver& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_CloudRegisterReceiver::IsInitialized() const { + return true; +} + +void SharingLog_CloudRegisterReceiver::InternalSwap(SharingLog_CloudRegisterReceiver* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(result_, other->result_); +} + +std::string SharingLog_CloudRegisterReceiver::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver"; +} + + +// =================================================================== + +class SharingLog_CloudUploadStart::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& attachments_info(const SharingLog_CloudUploadStart* msg); + static void set_has_attachments_info(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_action_type(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& +SharingLog_CloudUploadStart::_Internal::attachments_info(const SharingLog_CloudUploadStart* msg) { + return *msg->attachments_info_; +} +SharingLog_CloudUploadStart::SharingLog_CloudUploadStart(::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:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) +} +SharingLog_CloudUploadStart::SharingLog_CloudUploadStart(const SharingLog_CloudUploadStart& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_attachments_info()) { + attachments_info_ = new ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo(*from.attachments_info_); + } else { + attachments_info_ = nullptr; + } + action_type_ = from.action_type_; + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) +} + +inline void SharingLog_CloudUploadStart::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&attachments_info_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&action_type_) - + reinterpret_cast(&attachments_info_)) + sizeof(action_type_)); +} + +SharingLog_CloudUploadStart::~SharingLog_CloudUploadStart() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_CloudUploadStart::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete attachments_info_; +} + +void SharingLog_CloudUploadStart::ArenaDtor(void* object) { + SharingLog_CloudUploadStart* _this = reinterpret_cast< SharingLog_CloudUploadStart* >(object); + (void)_this; +} +void SharingLog_CloudUploadStart::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_CloudUploadStart::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_CloudUploadStart::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) + 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(attachments_info_ != nullptr); + attachments_info_->Clear(); + } + action_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_CloudUploadStart::_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 .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_attachments_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.proto.sharing.CloudActionType action_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::proto::sharing::CloudActionType_IsValid(val))) { + _internal_set_action_type(static_cast<::location::nearby::proto::sharing::CloudActionType>(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* SharingLog_CloudUploadStart::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::attachments_info(this), target, stream); + } + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_action_type(), 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:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) + return target; +} + +size_t SharingLog_CloudUploadStart::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) + 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 .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *attachments_info_); + } + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_action_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 SharingLog_CloudUploadStart::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_CloudUploadStart::MergeFrom(const SharingLog_CloudUploadStart& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) + 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_attachments_info()->::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo::MergeFrom(from._internal_attachments_info()); + } + if (cached_has_bits & 0x00000002u) { + action_type_ = from.action_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_CloudUploadStart::CopyFrom(const SharingLog_CloudUploadStart& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_CloudUploadStart::IsInitialized() const { + return true; +} + +void SharingLog_CloudUploadStart::InternalSwap(SharingLog_CloudUploadStart* 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(SharingLog_CloudUploadStart, action_type_) + + sizeof(SharingLog_CloudUploadStart::action_type_) + - PROTOBUF_FIELD_OFFSET(SharingLog_CloudUploadStart, attachments_info_)>( + reinterpret_cast(&attachments_info_), + reinterpret_cast(&other->attachments_info_)); +} + +std::string SharingLog_CloudUploadStart::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.CloudUploadStart"; +} + + +// =================================================================== + +class SharingLog_CloudUploadEnd::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_action_type(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SharingLog_CloudUploadEnd::SharingLog_CloudUploadEnd(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + upload_infos_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) +} +SharingLog_CloudUploadEnd::SharingLog_CloudUploadEnd(const SharingLog_CloudUploadEnd& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + upload_infos_(from.upload_infos_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + action_type_ = from.action_type_; + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) +} + +inline void SharingLog_CloudUploadEnd::SharedCtor() { +action_type_ = 0; +} + +SharingLog_CloudUploadEnd::~SharingLog_CloudUploadEnd() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_CloudUploadEnd::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SharingLog_CloudUploadEnd::ArenaDtor(void* object) { + SharingLog_CloudUploadEnd* _this = reinterpret_cast< SharingLog_CloudUploadEnd* >(object); + (void)_this; +} +void SharingLog_CloudUploadEnd::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_CloudUploadEnd::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_CloudUploadEnd::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + upload_infos_.Clear(); + action_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_CloudUploadEnd::_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) { + // repeated .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo upload_infos = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_upload_infos(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional .location.nearby.proto.sharing.CloudActionType action_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::proto::sharing::CloudActionType_IsValid(val))) { + _internal_set_action_type(static_cast<::location::nearby::proto::sharing::CloudActionType>(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* SharingLog_CloudUploadEnd::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo upload_infos = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_upload_infos_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_upload_infos(i), target, stream); + } + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_action_type(), 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:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) + return target; +} + +size_t SharingLog_CloudUploadEnd::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) + 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 .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo upload_infos = 1; + total_size += 1UL * this->_internal_upload_infos_size(); + for (const auto& msg : this->upload_infos_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_action_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 SharingLog_CloudUploadEnd::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_CloudUploadEnd::MergeFrom(const SharingLog_CloudUploadEnd& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + upload_infos_.MergeFrom(from.upload_infos_); + if (from._internal_has_action_type()) { + _internal_set_action_type(from._internal_action_type()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_CloudUploadEnd::CopyFrom(const SharingLog_CloudUploadEnd& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_CloudUploadEnd::IsInitialized() const { + return true; +} + +void SharingLog_CloudUploadEnd::InternalSwap(SharingLog_CloudUploadEnd* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + upload_infos_.InternalSwap(&other->upload_infos_); + swap(action_type_, other->action_type_); +} + +std::string SharingLog_CloudUploadEnd::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd"; +} + + +// =================================================================== + +class SharingLog_CloudDownloadStart::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& attachments_info(const SharingLog_CloudDownloadStart* msg); + static void set_has_attachments_info(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_action_type(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& +SharingLog_CloudDownloadStart::_Internal::attachments_info(const SharingLog_CloudDownloadStart* msg) { + return *msg->attachments_info_; +} +SharingLog_CloudDownloadStart::SharingLog_CloudDownloadStart(::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:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) +} +SharingLog_CloudDownloadStart::SharingLog_CloudDownloadStart(const SharingLog_CloudDownloadStart& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_attachments_info()) { + attachments_info_ = new ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo(*from.attachments_info_); + } else { + attachments_info_ = nullptr; + } + action_type_ = from.action_type_; + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) +} + +inline void SharingLog_CloudDownloadStart::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&attachments_info_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&action_type_) - + reinterpret_cast(&attachments_info_)) + sizeof(action_type_)); +} + +SharingLog_CloudDownloadStart::~SharingLog_CloudDownloadStart() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_CloudDownloadStart::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete attachments_info_; +} + +void SharingLog_CloudDownloadStart::ArenaDtor(void* object) { + SharingLog_CloudDownloadStart* _this = reinterpret_cast< SharingLog_CloudDownloadStart* >(object); + (void)_this; +} +void SharingLog_CloudDownloadStart::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_CloudDownloadStart::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_CloudDownloadStart::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) + 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(attachments_info_ != nullptr); + attachments_info_->Clear(); + } + action_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_CloudDownloadStart::_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 .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_attachments_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .location.nearby.proto.sharing.CloudActionType action_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::proto::sharing::CloudActionType_IsValid(val))) { + _internal_set_action_type(static_cast<::location::nearby::proto::sharing::CloudActionType>(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* SharingLog_CloudDownloadStart::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::attachments_info(this), target, stream); + } + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_action_type(), 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:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) + return target; +} + +size_t SharingLog_CloudDownloadStart::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) + 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 .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *attachments_info_); + } + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_action_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 SharingLog_CloudDownloadStart::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_CloudDownloadStart::MergeFrom(const SharingLog_CloudDownloadStart& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) + 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_attachments_info()->::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo::MergeFrom(from._internal_attachments_info()); + } + if (cached_has_bits & 0x00000002u) { + action_type_ = from.action_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_CloudDownloadStart::CopyFrom(const SharingLog_CloudDownloadStart& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_CloudDownloadStart::IsInitialized() const { + return true; +} + +void SharingLog_CloudDownloadStart::InternalSwap(SharingLog_CloudDownloadStart* 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(SharingLog_CloudDownloadStart, action_type_) + + sizeof(SharingLog_CloudDownloadStart::action_type_) + - PROTOBUF_FIELD_OFFSET(SharingLog_CloudDownloadStart, attachments_info_)>( + reinterpret_cast(&attachments_info_), + reinterpret_cast(&other->attachments_info_)); +} + +std::string SharingLog_CloudDownloadStart::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart"; +} + + +// =================================================================== + +class SharingLog_CloudDownloadEnd::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_action_type(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +SharingLog_CloudDownloadEnd::SharingLog_CloudDownloadEnd(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + download_infos_(arena) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) +} +SharingLog_CloudDownloadEnd::SharingLog_CloudDownloadEnd(const SharingLog_CloudDownloadEnd& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + download_infos_(from.download_infos_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + action_type_ = from.action_type_; + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) +} + +inline void SharingLog_CloudDownloadEnd::SharedCtor() { +action_type_ = 0; +} + +SharingLog_CloudDownloadEnd::~SharingLog_CloudDownloadEnd() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_CloudDownloadEnd::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void SharingLog_CloudDownloadEnd::ArenaDtor(void* object) { + SharingLog_CloudDownloadEnd* _this = reinterpret_cast< SharingLog_CloudDownloadEnd* >(object); + (void)_this; +} +void SharingLog_CloudDownloadEnd::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_CloudDownloadEnd::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_CloudDownloadEnd::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + download_infos_.Clear(); + action_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_CloudDownloadEnd::_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) { + // repeated .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo download_infos = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_download_infos(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional .location.nearby.proto.sharing.CloudActionType action_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::proto::sharing::CloudActionType_IsValid(val))) { + _internal_set_action_type(static_cast<::location::nearby::proto::sharing::CloudActionType>(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* SharingLog_CloudDownloadEnd::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo download_infos = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_download_infos_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_download_infos(i), target, stream); + } + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_action_type(), 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:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) + return target; +} + +size_t SharingLog_CloudDownloadEnd::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) + 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 .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo download_infos = 1; + total_size += 1UL * this->_internal_download_infos_size(); + for (const auto& msg : this->download_infos_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_action_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 SharingLog_CloudDownloadEnd::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_CloudDownloadEnd::MergeFrom(const SharingLog_CloudDownloadEnd& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + download_infos_.MergeFrom(from.download_infos_); + if (from._internal_has_action_type()) { + _internal_set_action_type(from._internal_action_type()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_CloudDownloadEnd::CopyFrom(const SharingLog_CloudDownloadEnd& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_CloudDownloadEnd::IsInitialized() const { + return true; +} + +void SharingLog_CloudDownloadEnd::InternalSwap(SharingLog_CloudDownloadEnd* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + download_infos_.InternalSwap(&other->download_infos_); + swap(action_type_, other->action_type_); +} + +std::string SharingLog_CloudDownloadEnd::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd"; +} + + +// =================================================================== + +class SharingLog_CloudSharingRpcResult::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_rpc_name(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } + static void set_has_status_code(HasBits* has_bits) { + (*has_bits)[0] |= 8u; + } + static void set_has_latency_millis(HasBits* has_bits) { + (*has_bits)[0] |= 4u; + } + static void set_has_cloud_sharing_id(HasBits* has_bits) { + (*has_bits)[0] |= 2u; + } +}; + +SharingLog_CloudSharingRpcResult::SharingLog_CloudSharingRpcResult(::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:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) +} +SharingLog_CloudSharingRpcResult::SharingLog_CloudSharingRpcResult(const SharingLog_CloudSharingRpcResult& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + rpc_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + rpc_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_rpc_name()) { + rpc_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_rpc_name(), + GetArenaForAllocation()); + } + cloud_sharing_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + cloud_sharing_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_cloud_sharing_id()) { + cloud_sharing_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_cloud_sharing_id(), + GetArenaForAllocation()); + } + ::memcpy(&latency_millis_, &from.latency_millis_, + static_cast(reinterpret_cast(&status_code_) - + reinterpret_cast(&latency_millis_)) + sizeof(status_code_)); + // @@protoc_insertion_point(copy_constructor:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) +} + +inline void SharingLog_CloudSharingRpcResult::SharedCtor() { +rpc_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + rpc_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +cloud_sharing_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + cloud_sharing_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&latency_millis_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&status_code_) - + reinterpret_cast(&latency_millis_)) + sizeof(status_code_)); +} + +SharingLog_CloudSharingRpcResult::~SharingLog_CloudSharingRpcResult() { + // @@protoc_insertion_point(destructor:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void SharingLog_CloudSharingRpcResult::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + rpc_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + cloud_sharing_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SharingLog_CloudSharingRpcResult::ArenaDtor(void* object) { + SharingLog_CloudSharingRpcResult* _this = reinterpret_cast< SharingLog_CloudSharingRpcResult* >(object); + (void)_this; +} +void SharingLog_CloudSharingRpcResult::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SharingLog_CloudSharingRpcResult::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SharingLog_CloudSharingRpcResult::Clear() { +// @@protoc_insertion_point(message_clear_start:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) + 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) { + rpc_name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + cloud_sharing_id_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000000cu) { + ::memset(&latency_millis_, 0, static_cast( + reinterpret_cast(&status_code_) - + reinterpret_cast(&latency_millis_)) + sizeof(status_code_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* SharingLog_CloudSharingRpcResult::_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 rpc_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_rpc_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 status_code = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_status_code(&has_bits); + status_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 latency_millis = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_latency_millis(&has_bits); + latency_millis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string cloud_sharing_id = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_cloud_sharing_id(); + 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* SharingLog_CloudSharingRpcResult::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string rpc_name = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased( + 1, this->_internal_rpc_name(), target); + } + + // optional int32 status_code = 2; + if (cached_has_bits & 0x00000008u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_status_code(), target); + } + + // optional int64 latency_millis = 3; + if (cached_has_bits & 0x00000004u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_latency_millis(), target); + } + + // optional string cloud_sharing_id = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 4, this->_internal_cloud_sharing_id(), 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:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) + return target; +} + +size_t SharingLog_CloudSharingRpcResult::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) + 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 string rpc_name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_rpc_name()); + } + + // optional string cloud_sharing_id = 4; + if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_cloud_sharing_id()); + } + + // optional int64 latency_millis = 3; + if (cached_has_bits & 0x00000004u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_latency_millis()); + } + + // optional int32 status_code = 2; + if (cached_has_bits & 0x00000008u) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_status_code()); + } + + } + 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 SharingLog_CloudSharingRpcResult::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void SharingLog_CloudSharingRpcResult::MergeFrom(const SharingLog_CloudSharingRpcResult& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) + 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_set_rpc_name(from._internal_rpc_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_cloud_sharing_id(from._internal_cloud_sharing_id()); + } + if (cached_has_bits & 0x00000004u) { + latency_millis_ = from.latency_millis_; + } + if (cached_has_bits & 0x00000008u) { + status_code_ = from.status_code_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SharingLog_CloudSharingRpcResult::CopyFrom(const SharingLog_CloudSharingRpcResult& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SharingLog_CloudSharingRpcResult::IsInitialized() const { + return true; +} + +void SharingLog_CloudSharingRpcResult::InternalSwap(SharingLog_CloudSharingRpcResult* 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(), + &rpc_name_, lhs_arena, + &other->rpc_name_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &cloud_sharing_id_, lhs_arena, + &other->cloud_sharing_id_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SharingLog_CloudSharingRpcResult, status_code_) + + sizeof(SharingLog_CloudSharingRpcResult::status_code_) + - PROTOBUF_FIELD_OFFSET(SharingLog_CloudSharingRpcResult, latency_millis_)>( + reinterpret_cast(&latency_millis_), + reinterpret_cast(&other->latency_millis_)); +} + +std::string SharingLog_CloudSharingRpcResult::GetTypeName() const { + return "nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult"; +} + + // =================================================================== class SharingLog::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_event_type(HasBits* has_bits) { - (*has_bits)[2] |= 128u; + (*has_bits)[2] |= 2097152u; } static const ::nearby::sharing::analytics::proto::SharingLog_UnknownEvent& unknown_event(const SharingLog* msg); static void set_has_unknown_event(HasBits* has_bits) { @@ -20092,7 +25621,7 @@ class SharingLog::_Internal { (*has_bits)[0] |= 134217728u; } static void set_has_log_source(HasBits* has_bits) { - (*has_bits)[2] |= 256u; + (*has_bits)[2] |= 4194304u; } static const ::nearby::sharing::analytics::proto::SharingLog_FastShareServerResponse& fast_share_server_response(const SharingLog* msg); static void set_has_fast_share_server_response(HasBits* has_bits) { @@ -20114,7 +25643,7 @@ class SharingLog::_Internal { (*has_bits)[0] |= 1u; } static void set_has_event_category(HasBits* has_bits) { - (*has_bits)[2] |= 512u; + (*has_bits)[2] |= 8388608u; } static const ::nearby::sharing::analytics::proto::SharingLog_DismissFastInitialization& dismiss_fast_initialization(const SharingLog* msg); static void set_has_dismiss_fast_initialization(HasBits* has_bits) { @@ -20278,6 +25807,62 @@ class SharingLog::_Internal { static void set_has_show_allow_permission_auto_access(HasBits* has_bits) { (*has_bits)[2] |= 64u; } + static const ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept& show_waiting_for_accept(const SharingLog* msg); + static void set_has_show_waiting_for_accept(HasBits* has_bits) { + (*has_bits)[2] |= 128u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup& high_quality_medium_setup(const SharingLog* msg); + static void set_has_high_quality_medium_setup(HasBits* has_bits) { + (*has_bits)[2] |= 256u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus& rpc_call_status(const SharingLog* msg); + static void set_has_rpc_call_status(HasBits* has_bits) { + (*has_bits)[2] |= 512u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession& start_qr_code_session(const SharingLog* msg); + static void set_has_start_qr_code_session(HasBits* has_bits) { + (*has_bits)[2] |= 1024u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient& qr_code_opened_in_web_client(const SharingLog* msg); + static void set_has_qr_code_opened_in_web_client(HasBits* has_bits) { + (*has_bits)[2] |= 2048u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent& hats_joint_event(const SharingLog* msg); + static void set_has_hats_joint_event(HasBits* has_bits) { + (*has_bits)[2] |= 4096u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews& receive_previews(const SharingLog* msg); + static void set_has_receive_previews(HasBits* has_bits) { + (*has_bits)[2] |= 8192u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest& cloud_create_sharing_request(const SharingLog* msg); + static void set_has_cloud_create_sharing_request(HasBits* has_bits) { + (*has_bits)[2] |= 16384u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver& cloud_register_receiver(const SharingLog* msg); + static void set_has_cloud_register_receiver(HasBits* has_bits) { + (*has_bits)[2] |= 32768u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart& cloud_upload_start(const SharingLog* msg); + static void set_has_cloud_upload_start(HasBits* has_bits) { + (*has_bits)[2] |= 65536u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd& cloud_upload_end(const SharingLog* msg); + static void set_has_cloud_upload_end(HasBits* has_bits) { + (*has_bits)[2] |= 131072u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart& cloud_download_start(const SharingLog* msg); + static void set_has_cloud_download_start(HasBits* has_bits) { + (*has_bits)[2] |= 262144u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd& cloud_download_end(const SharingLog* msg); + static void set_has_cloud_download_end(HasBits* has_bits) { + (*has_bits)[2] |= 524288u; + } + static const ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult& cloud_sharing_rpc_result(const SharingLog* msg); + static void set_has_cloud_sharing_rpc_result(HasBits* has_bits) { + (*has_bits)[2] |= 1048576u; + } }; const ::nearby::sharing::analytics::proto::SharingLog_UnknownEvent& @@ -20552,6 +26137,62 @@ const ::nearby::sharing::analytics::proto::SharingLog_ShowAllowPermissionAutoAcc SharingLog::_Internal::show_allow_permission_auto_access(const SharingLog* msg) { return *msg->show_allow_permission_auto_access_; } +const ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept& +SharingLog::_Internal::show_waiting_for_accept(const SharingLog* msg) { + return *msg->show_waiting_for_accept_; +} +const ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup& +SharingLog::_Internal::high_quality_medium_setup(const SharingLog* msg) { + return *msg->high_quality_medium_setup_; +} +const ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus& +SharingLog::_Internal::rpc_call_status(const SharingLog* msg) { + return *msg->rpc_call_status_; +} +const ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession& +SharingLog::_Internal::start_qr_code_session(const SharingLog* msg) { + return *msg->start_qr_code_session_; +} +const ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient& +SharingLog::_Internal::qr_code_opened_in_web_client(const SharingLog* msg) { + return *msg->qr_code_opened_in_web_client_; +} +const ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent& +SharingLog::_Internal::hats_joint_event(const SharingLog* msg) { + return *msg->hats_joint_event_; +} +const ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews& +SharingLog::_Internal::receive_previews(const SharingLog* msg) { + return *msg->receive_previews_; +} +const ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest& +SharingLog::_Internal::cloud_create_sharing_request(const SharingLog* msg) { + return *msg->cloud_create_sharing_request_; +} +const ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver& +SharingLog::_Internal::cloud_register_receiver(const SharingLog* msg) { + return *msg->cloud_register_receiver_; +} +const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart& +SharingLog::_Internal::cloud_upload_start(const SharingLog* msg) { + return *msg->cloud_upload_start_; +} +const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd& +SharingLog::_Internal::cloud_upload_end(const SharingLog* msg) { + return *msg->cloud_upload_end_; +} +const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart& +SharingLog::_Internal::cloud_download_start(const SharingLog* msg) { + return *msg->cloud_download_start_; +} +const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd& +SharingLog::_Internal::cloud_download_end(const SharingLog* msg) { + return *msg->cloud_download_end_; +} +const ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult& +SharingLog::_Internal::cloud_sharing_rpc_result(const SharingLog* msg) { + return *msg->cloud_sharing_rpc_result_; +} SharingLog::SharingLog(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { @@ -20929,6 +26570,76 @@ SharingLog::SharingLog(const SharingLog& from) } else { show_allow_permission_auto_access_ = nullptr; } + if (from._internal_has_show_waiting_for_accept()) { + show_waiting_for_accept_ = new ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept(*from.show_waiting_for_accept_); + } else { + show_waiting_for_accept_ = nullptr; + } + if (from._internal_has_high_quality_medium_setup()) { + high_quality_medium_setup_ = new ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup(*from.high_quality_medium_setup_); + } else { + high_quality_medium_setup_ = nullptr; + } + if (from._internal_has_rpc_call_status()) { + rpc_call_status_ = new ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus(*from.rpc_call_status_); + } else { + rpc_call_status_ = nullptr; + } + if (from._internal_has_start_qr_code_session()) { + start_qr_code_session_ = new ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession(*from.start_qr_code_session_); + } else { + start_qr_code_session_ = nullptr; + } + if (from._internal_has_qr_code_opened_in_web_client()) { + qr_code_opened_in_web_client_ = new ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient(*from.qr_code_opened_in_web_client_); + } else { + qr_code_opened_in_web_client_ = nullptr; + } + if (from._internal_has_hats_joint_event()) { + hats_joint_event_ = new ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent(*from.hats_joint_event_); + } else { + hats_joint_event_ = nullptr; + } + if (from._internal_has_receive_previews()) { + receive_previews_ = new ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews(*from.receive_previews_); + } else { + receive_previews_ = nullptr; + } + if (from._internal_has_cloud_create_sharing_request()) { + cloud_create_sharing_request_ = new ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest(*from.cloud_create_sharing_request_); + } else { + cloud_create_sharing_request_ = nullptr; + } + if (from._internal_has_cloud_register_receiver()) { + cloud_register_receiver_ = new ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver(*from.cloud_register_receiver_); + } else { + cloud_register_receiver_ = nullptr; + } + if (from._internal_has_cloud_upload_start()) { + cloud_upload_start_ = new ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart(*from.cloud_upload_start_); + } else { + cloud_upload_start_ = nullptr; + } + if (from._internal_has_cloud_upload_end()) { + cloud_upload_end_ = new ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd(*from.cloud_upload_end_); + } else { + cloud_upload_end_ = nullptr; + } + if (from._internal_has_cloud_download_start()) { + cloud_download_start_ = new ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart(*from.cloud_download_start_); + } else { + cloud_download_start_ = nullptr; + } + if (from._internal_has_cloud_download_end()) { + cloud_download_end_ = new ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd(*from.cloud_download_end_); + } else { + cloud_download_end_ = nullptr; + } + if (from._internal_has_cloud_sharing_rpc_result()) { + cloud_sharing_rpc_result_ = new ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult(*from.cloud_sharing_rpc_result_); + } else { + cloud_sharing_rpc_result_ = nullptr; + } ::memcpy(&event_type_, &from.event_type_, static_cast(reinterpret_cast(&event_category_) - reinterpret_cast(&event_type_)) + sizeof(event_category_)); @@ -21034,6 +26745,20 @@ inline void SharingLog::SharedDtor() { if (this != internal_default_instance()) delete set_account_; if (this != internal_default_instance()) delete decrypt_certificate_failure_; if (this != internal_default_instance()) delete show_allow_permission_auto_access_; + if (this != internal_default_instance()) delete show_waiting_for_accept_; + if (this != internal_default_instance()) delete high_quality_medium_setup_; + if (this != internal_default_instance()) delete rpc_call_status_; + if (this != internal_default_instance()) delete start_qr_code_session_; + if (this != internal_default_instance()) delete qr_code_opened_in_web_client_; + if (this != internal_default_instance()) delete hats_joint_event_; + if (this != internal_default_instance()) delete receive_previews_; + if (this != internal_default_instance()) delete cloud_create_sharing_request_; + if (this != internal_default_instance()) delete cloud_register_receiver_; + if (this != internal_default_instance()) delete cloud_upload_start_; + if (this != internal_default_instance()) delete cloud_upload_end_; + if (this != internal_default_instance()) delete cloud_download_start_; + if (this != internal_default_instance()) delete cloud_download_end_; + if (this != internal_default_instance()) delete cloud_sharing_rpc_result_; } void SharingLog::ArenaDtor(void* object) { @@ -21324,7 +27049,7 @@ void SharingLog::Clear() { } } cached_has_bits = _has_bits_[2]; - if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x000000ffu) { if (cached_has_bits & 0x00000001u) { GOOGLE_DCHECK(parsing_failed_endpoint_id_ != nullptr); parsing_failed_endpoint_id_->Clear(); @@ -21353,12 +27078,71 @@ void SharingLog::Clear() { GOOGLE_DCHECK(show_allow_permission_auto_access_ != nullptr); show_allow_permission_auto_access_->Clear(); } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(show_waiting_for_accept_ != nullptr); + show_waiting_for_accept_->Clear(); + } } - event_type_ = 0; - if (cached_has_bits & 0x00000300u) { - ::memset(&log_source_, 0, static_cast( + if (cached_has_bits & 0x0000ff00u) { + if (cached_has_bits & 0x00000100u) { + GOOGLE_DCHECK(high_quality_medium_setup_ != nullptr); + high_quality_medium_setup_->Clear(); + } + if (cached_has_bits & 0x00000200u) { + GOOGLE_DCHECK(rpc_call_status_ != nullptr); + rpc_call_status_->Clear(); + } + if (cached_has_bits & 0x00000400u) { + GOOGLE_DCHECK(start_qr_code_session_ != nullptr); + start_qr_code_session_->Clear(); + } + if (cached_has_bits & 0x00000800u) { + GOOGLE_DCHECK(qr_code_opened_in_web_client_ != nullptr); + qr_code_opened_in_web_client_->Clear(); + } + if (cached_has_bits & 0x00001000u) { + GOOGLE_DCHECK(hats_joint_event_ != nullptr); + hats_joint_event_->Clear(); + } + if (cached_has_bits & 0x00002000u) { + GOOGLE_DCHECK(receive_previews_ != nullptr); + receive_previews_->Clear(); + } + if (cached_has_bits & 0x00004000u) { + GOOGLE_DCHECK(cloud_create_sharing_request_ != nullptr); + cloud_create_sharing_request_->Clear(); + } + if (cached_has_bits & 0x00008000u) { + GOOGLE_DCHECK(cloud_register_receiver_ != nullptr); + cloud_register_receiver_->Clear(); + } + } + if (cached_has_bits & 0x001f0000u) { + if (cached_has_bits & 0x00010000u) { + GOOGLE_DCHECK(cloud_upload_start_ != nullptr); + cloud_upload_start_->Clear(); + } + if (cached_has_bits & 0x00020000u) { + GOOGLE_DCHECK(cloud_upload_end_ != nullptr); + cloud_upload_end_->Clear(); + } + if (cached_has_bits & 0x00040000u) { + GOOGLE_DCHECK(cloud_download_start_ != nullptr); + cloud_download_start_->Clear(); + } + if (cached_has_bits & 0x00080000u) { + GOOGLE_DCHECK(cloud_download_end_ != nullptr); + cloud_download_end_->Clear(); + } + if (cached_has_bits & 0x00100000u) { + GOOGLE_DCHECK(cloud_sharing_rpc_result_ != nullptr); + cloud_sharing_rpc_result_->Clear(); + } + } + if (cached_has_bits & 0x00e00000u) { + ::memset(&event_type_, 0, static_cast( reinterpret_cast(&event_category_) - - reinterpret_cast(&log_source_)) + sizeof(event_category_)); + reinterpret_cast(&event_type_)) + sizeof(event_category_)); } _has_bits_.Clear(); _internal_metadata_.Clear(); @@ -21980,6 +27764,118 @@ const char* SharingLog::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: } else goto handle_unusual; continue; + // optional .nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept show_waiting_for_accept = 76; + case 76: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_show_waiting_for_accept(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup high_quality_medium_setup = 77; + case 77: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_high_quality_medium_setup(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus rpc_call_status = 78; + case 78: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_rpc_call_status(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession start_qr_code_session = 79; + case 79: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr = ctx->ParseMessage(_internal_mutable_start_qr_code_session(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient qr_code_opened_in_web_client = 80; + case 80: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_qr_code_opened_in_web_client(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.HatsJointEvent hats_joint_event = 81; + case 81: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_hats_joint_event(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.ReceivePreviews receive_previews = 82; + case 82: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 146)) { + ptr = ctx->ParseMessage(_internal_mutable_receive_previews(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest cloud_create_sharing_request = 83; + case 83: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_cloud_create_sharing_request(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver cloud_register_receiver = 84; + case 84: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_cloud_register_receiver(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadStart cloud_upload_start = 85; + case 85: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_cloud_upload_start(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd cloud_upload_end = 86; + case 86: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_cloud_upload_end(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart cloud_download_start = 87; + case 87: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_cloud_download_start(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd cloud_download_end = 88; + case 88: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_cloud_download_end(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult cloud_sharing_rpc_result = 89; + case 89: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_cloud_sharing_rpc_result(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -22011,7 +27907,7 @@ uint8_t* SharingLog::_InternalSerialize( cached_has_bits = _has_bits_[2]; // optional .location.nearby.proto.sharing.EventType event_type = 1; - if (cached_has_bits & 0x00000080u) { + if (cached_has_bits & 0x00200000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_event_type(), target); @@ -22220,7 +28116,7 @@ uint8_t* SharingLog::_InternalSerialize( cached_has_bits = _has_bits_[2]; // optional .location.nearby.proto.sharing.LogSource log_source = 27; - if (cached_has_bits & 0x00000100u) { + if (cached_has_bits & 0x00400000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 27, this->_internal_log_source(), target); @@ -22267,7 +28163,7 @@ uint8_t* SharingLog::_InternalSerialize( cached_has_bits = _has_bits_[2]; // optional .location.nearby.proto.sharing.EventCategory event_category = 33; - if (cached_has_bits & 0x00000200u) { + if (cached_has_bits & 0x00800000u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 33, this->_internal_event_category(), target); @@ -22603,6 +28499,118 @@ uint8_t* SharingLog::_InternalSerialize( 75, _Internal::show_allow_permission_auto_access(this), target, stream); } + // optional .nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept show_waiting_for_accept = 76; + if (cached_has_bits & 0x00000080u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 76, _Internal::show_waiting_for_accept(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup high_quality_medium_setup = 77; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 77, _Internal::high_quality_medium_setup(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus rpc_call_status = 78; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 78, _Internal::rpc_call_status(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession start_qr_code_session = 79; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 79, _Internal::start_qr_code_session(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient qr_code_opened_in_web_client = 80; + if (cached_has_bits & 0x00000800u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 80, _Internal::qr_code_opened_in_web_client(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.HatsJointEvent hats_joint_event = 81; + if (cached_has_bits & 0x00001000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 81, _Internal::hats_joint_event(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.ReceivePreviews receive_previews = 82; + if (cached_has_bits & 0x00002000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 82, _Internal::receive_previews(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest cloud_create_sharing_request = 83; + if (cached_has_bits & 0x00004000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 83, _Internal::cloud_create_sharing_request(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver cloud_register_receiver = 84; + if (cached_has_bits & 0x00008000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 84, _Internal::cloud_register_receiver(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadStart cloud_upload_start = 85; + if (cached_has_bits & 0x00010000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 85, _Internal::cloud_upload_start(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd cloud_upload_end = 86; + if (cached_has_bits & 0x00020000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 86, _Internal::cloud_upload_end(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart cloud_download_start = 87; + if (cached_has_bits & 0x00040000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 87, _Internal::cloud_download_start(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd cloud_download_end = 88; + if (cached_has_bits & 0x00080000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 88, _Internal::cloud_download_end(this), target, stream); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult cloud_sharing_rpc_result = 89; + if (cached_has_bits & 0x00100000u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 89, _Internal::cloud_sharing_rpc_result(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); @@ -23136,22 +29144,122 @@ size_t SharingLog::ByteSizeLong() const { *show_allow_permission_auto_access_); } - // optional .location.nearby.proto.sharing.EventType event_type = 1; + // optional .nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept show_waiting_for_accept = 76; if (cached_has_bits & 0x00000080u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *show_waiting_for_accept_); + } + + } + if (cached_has_bits & 0x0000ff00u) { + // optional .nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup high_quality_medium_setup = 77; + if (cached_has_bits & 0x00000100u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *high_quality_medium_setup_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus rpc_call_status = 78; + if (cached_has_bits & 0x00000200u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rpc_call_status_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession start_qr_code_session = 79; + if (cached_has_bits & 0x00000400u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *start_qr_code_session_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient qr_code_opened_in_web_client = 80; + if (cached_has_bits & 0x00000800u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *qr_code_opened_in_web_client_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.HatsJointEvent hats_joint_event = 81; + if (cached_has_bits & 0x00001000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *hats_joint_event_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.ReceivePreviews receive_previews = 82; + if (cached_has_bits & 0x00002000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *receive_previews_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest cloud_create_sharing_request = 83; + if (cached_has_bits & 0x00004000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *cloud_create_sharing_request_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver cloud_register_receiver = 84; + if (cached_has_bits & 0x00008000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *cloud_register_receiver_); + } + + } + if (cached_has_bits & 0x00ff0000u) { + // optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadStart cloud_upload_start = 85; + if (cached_has_bits & 0x00010000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *cloud_upload_start_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd cloud_upload_end = 86; + if (cached_has_bits & 0x00020000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *cloud_upload_end_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart cloud_download_start = 87; + if (cached_has_bits & 0x00040000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *cloud_download_start_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd cloud_download_end = 88; + if (cached_has_bits & 0x00080000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *cloud_download_end_); + } + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult cloud_sharing_rpc_result = 89; + if (cached_has_bits & 0x00100000u) { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *cloud_sharing_rpc_result_); + } + + // optional .location.nearby.proto.sharing.EventType event_type = 1; + if (cached_has_bits & 0x00200000u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_event_type()); } - } - if (cached_has_bits & 0x00000300u) { // optional .location.nearby.proto.sharing.LogSource log_source = 27; - if (cached_has_bits & 0x00000100u) { + if (cached_has_bits & 0x00400000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_log_source()); } // optional .location.nearby.proto.sharing.EventCategory event_category = 33; - if (cached_has_bits & 0x00000200u) { + if (cached_has_bits & 0x00800000u) { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_event_category()); } @@ -23411,15 +29519,58 @@ void SharingLog::MergeFrom(const SharingLog& from) { _internal_mutable_show_allow_permission_auto_access()->::nearby::sharing::analytics::proto::SharingLog_ShowAllowPermissionAutoAccess::MergeFrom(from._internal_show_allow_permission_auto_access()); } if (cached_has_bits & 0x00000080u) { - event_type_ = from.event_type_; + _internal_mutable_show_waiting_for_accept()->::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept::MergeFrom(from._internal_show_waiting_for_accept()); } - _has_bits_[2] |= cached_has_bits; } - if (cached_has_bits & 0x00000300u) { + if (cached_has_bits & 0x0000ff00u) { if (cached_has_bits & 0x00000100u) { - log_source_ = from.log_source_; + _internal_mutable_high_quality_medium_setup()->::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup::MergeFrom(from._internal_high_quality_medium_setup()); } if (cached_has_bits & 0x00000200u) { + _internal_mutable_rpc_call_status()->::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus::MergeFrom(from._internal_rpc_call_status()); + } + if (cached_has_bits & 0x00000400u) { + _internal_mutable_start_qr_code_session()->::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession::MergeFrom(from._internal_start_qr_code_session()); + } + if (cached_has_bits & 0x00000800u) { + _internal_mutable_qr_code_opened_in_web_client()->::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient::MergeFrom(from._internal_qr_code_opened_in_web_client()); + } + if (cached_has_bits & 0x00001000u) { + _internal_mutable_hats_joint_event()->::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent::MergeFrom(from._internal_hats_joint_event()); + } + if (cached_has_bits & 0x00002000u) { + _internal_mutable_receive_previews()->::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews::MergeFrom(from._internal_receive_previews()); + } + if (cached_has_bits & 0x00004000u) { + _internal_mutable_cloud_create_sharing_request()->::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest::MergeFrom(from._internal_cloud_create_sharing_request()); + } + if (cached_has_bits & 0x00008000u) { + _internal_mutable_cloud_register_receiver()->::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver::MergeFrom(from._internal_cloud_register_receiver()); + } + } + if (cached_has_bits & 0x00ff0000u) { + if (cached_has_bits & 0x00010000u) { + _internal_mutable_cloud_upload_start()->::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart::MergeFrom(from._internal_cloud_upload_start()); + } + if (cached_has_bits & 0x00020000u) { + _internal_mutable_cloud_upload_end()->::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd::MergeFrom(from._internal_cloud_upload_end()); + } + if (cached_has_bits & 0x00040000u) { + _internal_mutable_cloud_download_start()->::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart::MergeFrom(from._internal_cloud_download_start()); + } + if (cached_has_bits & 0x00080000u) { + _internal_mutable_cloud_download_end()->::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd::MergeFrom(from._internal_cloud_download_end()); + } + if (cached_has_bits & 0x00100000u) { + _internal_mutable_cloud_sharing_rpc_result()->::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult::MergeFrom(from._internal_cloud_sharing_rpc_result()); + } + if (cached_has_bits & 0x00200000u) { + event_type_ = from.event_type_; + } + if (cached_has_bits & 0x00400000u) { + log_source_ = from.log_source_; + } + if (cached_has_bits & 0x00800000u) { event_category_ = from.event_category_; } _has_bits_[2] |= cached_has_bits; @@ -23696,6 +29847,9 @@ template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_App template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment >(Arena* arena) { return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment >(arena); } +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >(arena); +} template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_AppCrash* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_AppCrash >(Arena* arena) { return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_AppCrash >(arena); } @@ -23708,6 +29862,48 @@ template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_Sen template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_SendDesktopTransferEvent* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_SendDesktopTransferEvent >(Arena* arena) { return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_SendDesktopTransferEvent >(arena); } +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd >(arena); +} +template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult >(Arena* arena) { + return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult >(arena); +} template<> PROTOBUF_NOINLINE ::nearby::sharing::analytics::proto::SharingLog* Arena::CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog >(Arena* arena) { return Arena::CreateMessageInternal< ::nearby::sharing::analytics::proto::SharingLog >(arena); } diff --git a/compiled_proto/sharing/proto/analytics/nearby_sharing_log.pb.h b/compiled_proto/sharing/proto/analytics/nearby_sharing_log.pb.h index 4c6a3d6a..05586d57 100644 --- a/compiled_proto/sharing/proto/analytics/nearby_sharing_log.pb.h +++ b/compiled_proto/sharing/proto/analytics/nearby_sharing_log.pb.h @@ -13,7 +13,7 @@ #error incompatible with your Protocol Buffer headers. Please update #error your headers. #endif -#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019005 < 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. @@ -47,7 +47,7 @@ struct TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto 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[77] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[92] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -102,6 +102,30 @@ extern SharingLog_CancelReceivingAttachmentsDefaultTypeInternal _SharingLog_Canc class SharingLog_CancelSendingAttachments; struct SharingLog_CancelSendingAttachmentsDefaultTypeInternal; extern SharingLog_CancelSendingAttachmentsDefaultTypeInternal _SharingLog_CancelSendingAttachments_default_instance_; +class SharingLog_CloudAttachmentInfo; +struct SharingLog_CloudAttachmentInfoDefaultTypeInternal; +extern SharingLog_CloudAttachmentInfoDefaultTypeInternal _SharingLog_CloudAttachmentInfo_default_instance_; +class SharingLog_CloudCreateSharingRequest; +struct SharingLog_CloudCreateSharingRequestDefaultTypeInternal; +extern SharingLog_CloudCreateSharingRequestDefaultTypeInternal _SharingLog_CloudCreateSharingRequest_default_instance_; +class SharingLog_CloudDownloadEnd; +struct SharingLog_CloudDownloadEndDefaultTypeInternal; +extern SharingLog_CloudDownloadEndDefaultTypeInternal _SharingLog_CloudDownloadEnd_default_instance_; +class SharingLog_CloudDownloadStart; +struct SharingLog_CloudDownloadStartDefaultTypeInternal; +extern SharingLog_CloudDownloadStartDefaultTypeInternal _SharingLog_CloudDownloadStart_default_instance_; +class SharingLog_CloudRegisterReceiver; +struct SharingLog_CloudRegisterReceiverDefaultTypeInternal; +extern SharingLog_CloudRegisterReceiverDefaultTypeInternal _SharingLog_CloudRegisterReceiver_default_instance_; +class SharingLog_CloudSharingRpcResult; +struct SharingLog_CloudSharingRpcResultDefaultTypeInternal; +extern SharingLog_CloudSharingRpcResultDefaultTypeInternal _SharingLog_CloudSharingRpcResult_default_instance_; +class SharingLog_CloudUploadEnd; +struct SharingLog_CloudUploadEndDefaultTypeInternal; +extern SharingLog_CloudUploadEndDefaultTypeInternal _SharingLog_CloudUploadEnd_default_instance_; +class SharingLog_CloudUploadStart; +struct SharingLog_CloudUploadStartDefaultTypeInternal; +extern SharingLog_CloudUploadStartDefaultTypeInternal _SharingLog_CloudUploadStart_default_instance_; class SharingLog_DeclineAgreements; struct SharingLog_DeclineAgreementsDefaultTypeInternal; extern SharingLog_DeclineAgreementsDefaultTypeInternal _SharingLog_DeclineAgreements_default_instance_; @@ -150,6 +174,12 @@ extern SharingLog_FastShareServerResponseDefaultTypeInternal _SharingLog_FastSha class SharingLog_FileAttachment; struct SharingLog_FileAttachmentDefaultTypeInternal; extern SharingLog_FileAttachmentDefaultTypeInternal _SharingLog_FileAttachment_default_instance_; +class SharingLog_HatsJointEvent; +struct SharingLog_HatsJointEventDefaultTypeInternal; +extern SharingLog_HatsJointEventDefaultTypeInternal _SharingLog_HatsJointEvent_default_instance_; +class SharingLog_HighQualityMediumSetup; +struct SharingLog_HighQualityMediumSetupDefaultTypeInternal; +extern SharingLog_HighQualityMediumSetupDefaultTypeInternal _SharingLog_HighQualityMediumSetup_default_instance_; class SharingLog_InstallAPKStatus; struct SharingLog_InstallAPKStatusDefaultTypeInternal; extern SharingLog_InstallAPKStatusDefaultTypeInternal _SharingLog_InstallAPKStatus_default_instance_; @@ -180,6 +210,9 @@ extern SharingLog_ProcessReceivedAttachmentsEndDefaultTypeInternal _SharingLog_P class SharingLog_QrCodeLinkShown; struct SharingLog_QrCodeLinkShownDefaultTypeInternal; extern SharingLog_QrCodeLinkShownDefaultTypeInternal _SharingLog_QrCodeLinkShown_default_instance_; +class SharingLog_QrCodeOpenedInWebClient; +struct SharingLog_QrCodeOpenedInWebClientDefaultTypeInternal; +extern SharingLog_QrCodeOpenedInWebClientDefaultTypeInternal _SharingLog_QrCodeOpenedInWebClient_default_instance_; class SharingLog_ReceiveAttachmentsEnd; struct SharingLog_ReceiveAttachmentsEndDefaultTypeInternal; extern SharingLog_ReceiveAttachmentsEndDefaultTypeInternal _SharingLog_ReceiveAttachmentsEnd_default_instance_; @@ -192,6 +225,9 @@ extern SharingLog_ReceiveFastInitializationDefaultTypeInternal _SharingLog_Recei class SharingLog_ReceiveIntroduction; struct SharingLog_ReceiveIntroductionDefaultTypeInternal; extern SharingLog_ReceiveIntroductionDefaultTypeInternal _SharingLog_ReceiveIntroduction_default_instance_; +class SharingLog_ReceivePreviews; +struct SharingLog_ReceivePreviewsDefaultTypeInternal; +extern SharingLog_ReceivePreviewsDefaultTypeInternal _SharingLog_ReceivePreviews_default_instance_; class SharingLog_RemoveContact; struct SharingLog_RemoveContactDefaultTypeInternal; extern SharingLog_RemoveContactDefaultTypeInternal _SharingLog_RemoveContact_default_instance_; @@ -204,6 +240,9 @@ extern SharingLog_RequestSettingPermissionsDefaultTypeInternal _SharingLog_Reque class SharingLog_RespondToIntroduction; struct SharingLog_RespondToIntroductionDefaultTypeInternal; extern SharingLog_RespondToIntroductionDefaultTypeInternal _SharingLog_RespondToIntroduction_default_instance_; +class SharingLog_RpcCallStatus; +struct SharingLog_RpcCallStatusDefaultTypeInternal; +extern SharingLog_RpcCallStatusDefaultTypeInternal _SharingLog_RpcCallStatus_default_instance_; class SharingLog_ScanForShareTargetsEnd; struct SharingLog_ScanForShareTargetsEndDefaultTypeInternal; extern SharingLog_ScanForShareTargetsEndDefaultTypeInternal _SharingLog_ScanForShareTargetsEnd_default_instance_; @@ -252,6 +291,12 @@ extern SharingLog_ShareTargetInfoDefaultTypeInternal _SharingLog_ShareTargetInfo class SharingLog_ShowAllowPermissionAutoAccess; struct SharingLog_ShowAllowPermissionAutoAccessDefaultTypeInternal; extern SharingLog_ShowAllowPermissionAutoAccessDefaultTypeInternal _SharingLog_ShowAllowPermissionAutoAccess_default_instance_; +class SharingLog_ShowWaitingForAccept; +struct SharingLog_ShowWaitingForAcceptDefaultTypeInternal; +extern SharingLog_ShowWaitingForAcceptDefaultTypeInternal _SharingLog_ShowWaitingForAccept_default_instance_; +class SharingLog_StartQrCodeSession; +struct SharingLog_StartQrCodeSessionDefaultTypeInternal; +extern SharingLog_StartQrCodeSessionDefaultTypeInternal _SharingLog_StartQrCodeSession_default_instance_; class SharingLog_StreamAttachment; struct SharingLog_StreamAttachmentDefaultTypeInternal; extern SharingLog_StreamAttachmentDefaultTypeInternal _SharingLog_StreamAttachment_default_instance_; @@ -308,6 +353,14 @@ template<> ::nearby::sharing::analytics::proto::SharingLog_AutoDismissFastInitia template<> ::nearby::sharing::analytics::proto::SharingLog_CancelConnection* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CancelConnection>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_CancelReceivingAttachments* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CancelReceivingAttachments>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_CancelSendingAttachments* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CancelSendingAttachments>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_DeclineAgreements* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_DeclineAgreements>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_DecryptCertificateFailure* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_DecryptCertificateFailure>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_DefaultOptIn* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_DefaultOptIn>(Arena*); @@ -324,6 +377,8 @@ template<> ::nearby::sharing::analytics::proto::SharingLog_EventMetadata* Arena: template<> ::nearby::sharing::analytics::proto::SharingLog_FastInitDiscoverDevice* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_FastInitDiscoverDevice>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_FastShareServerResponse* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_FastShareServerResponse>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_FileAttachment>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_InstallAPKStatus* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_InstallAPKStatus>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_LaunchActivity* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_LaunchActivity>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_LaunchConsent* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_LaunchConsent>(Arena*); @@ -334,14 +389,17 @@ template<> ::nearby::sharing::analytics::proto::SharingLog_ParsingFailedEndpoint template<> ::nearby::sharing::analytics::proto::SharingLog_PreferencesUsage* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_PreferencesUsage>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_ProcessReceivedAttachmentsEnd* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ProcessReceivedAttachmentsEnd>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_QrCodeLinkShown* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_QrCodeLinkShown>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_ReceiveAttachmentsEnd* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ReceiveAttachmentsEnd>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_ReceiveAttachmentsStart* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ReceiveAttachmentsStart>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_ReceiveFastInitialization* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ReceiveFastInitialization>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_ReceiveIntroduction* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ReceiveIntroduction>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_RemoveContact* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_RemoveContact>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_RemoveQuickSettingsTile* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_RemoveQuickSettingsTile>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_RequestSettingPermissions* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_RequestSettingPermissions>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_RespondToIntroduction* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_RespondToIntroduction>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_ScanForShareTargetsEnd* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ScanForShareTargetsEnd>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_ScanForShareTargetsStart* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ScanForShareTargetsStart>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_SendAttachmentsEnd* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_SendAttachmentsEnd>(Arena*); @@ -358,6 +416,8 @@ template<> ::nearby::sharing::analytics::proto::SharingLog_SetVisibility* Arena: template<> ::nearby::sharing::analytics::proto::SharingLog_SetupWizard* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_SetupWizard>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_ShowAllowPermissionAutoAccess* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ShowAllowPermissionAutoAccess>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept>(Arena*); +template<> ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_StreamAttachment>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_TapFeedback* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_TapFeedback>(Arena*); template<> ::nearby::sharing::analytics::proto::SharingLog_TapHelp* Arena::CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_TapHelp>(Arena*); @@ -403,11 +463,12 @@ enum SharingLog_FileAttachment_Type : int { SharingLog_FileAttachment_Type_VIDEO = 2, SharingLog_FileAttachment_Type_ANDROID_APP = 3, SharingLog_FileAttachment_Type_AUDIO = 4, - SharingLog_FileAttachment_Type_DOCUMENT = 5 + SharingLog_FileAttachment_Type_DOCUMENT = 5, + SharingLog_FileAttachment_Type_CONTACT_CARD = 6 }; bool SharingLog_FileAttachment_Type_IsValid(int value); constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment_Type_Type_MIN = SharingLog_FileAttachment_Type_UNKNOWN_FILE_TYPE; -constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment_Type_Type_MAX = SharingLog_FileAttachment_Type_DOCUMENT; +constexpr SharingLog_FileAttachment_Type SharingLog_FileAttachment_Type_Type_MAX = SharingLog_FileAttachment_Type_CONTACT_CARD; constexpr int SharingLog_FileAttachment_Type_Type_ARRAYSIZE = SharingLog_FileAttachment_Type_Type_MAX + 1; const std::string& SharingLog_FileAttachment_Type_Name(SharingLog_FileAttachment_Type value); @@ -420,6 +481,49 @@ inline const std::string& SharingLog_FileAttachment_Type_Name(T enum_t_value) { } bool SharingLog_FileAttachment_Type_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SharingLog_FileAttachment_Type* value); +enum SharingLog_RpcCallStatus_RpcDirection : int { + SharingLog_RpcCallStatus_RpcDirection_UNKNOWN_RPC_DIRECTION = 0, + SharingLog_RpcCallStatus_RpcDirection_INCOMING = 1, + SharingLog_RpcCallStatus_RpcDirection_OUTGOING = 2 +}; +bool SharingLog_RpcCallStatus_RpcDirection_IsValid(int value); +constexpr SharingLog_RpcCallStatus_RpcDirection SharingLog_RpcCallStatus_RpcDirection_RpcDirection_MIN = SharingLog_RpcCallStatus_RpcDirection_UNKNOWN_RPC_DIRECTION; +constexpr SharingLog_RpcCallStatus_RpcDirection SharingLog_RpcCallStatus_RpcDirection_RpcDirection_MAX = SharingLog_RpcCallStatus_RpcDirection_OUTGOING; +constexpr int SharingLog_RpcCallStatus_RpcDirection_RpcDirection_ARRAYSIZE = SharingLog_RpcCallStatus_RpcDirection_RpcDirection_MAX + 1; + +const std::string& SharingLog_RpcCallStatus_RpcDirection_Name(SharingLog_RpcCallStatus_RpcDirection value); +template +inline const std::string& SharingLog_RpcCallStatus_RpcDirection_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SharingLog_RpcCallStatus_RpcDirection_Name."); + return SharingLog_RpcCallStatus_RpcDirection_Name(static_cast(enum_t_value)); +} +bool SharingLog_RpcCallStatus_RpcDirection_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SharingLog_RpcCallStatus_RpcDirection* value); +enum SharingLog_QrCodeOpenedInWebClient_ClientPlatform : int { + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_UNKNOWN_CLIENT_PLATFORM = 0, + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_GENERIC = 1, + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_ANDROID = 2, + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_IOS = 3, + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_CHROME_OS = 4, + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_WINDOWS = 5 +}; +bool SharingLog_QrCodeOpenedInWebClient_ClientPlatform_IsValid(int value); +constexpr SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient_ClientPlatform_ClientPlatform_MIN = SharingLog_QrCodeOpenedInWebClient_ClientPlatform_UNKNOWN_CLIENT_PLATFORM; +constexpr SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient_ClientPlatform_ClientPlatform_MAX = SharingLog_QrCodeOpenedInWebClient_ClientPlatform_WINDOWS; +constexpr int SharingLog_QrCodeOpenedInWebClient_ClientPlatform_ClientPlatform_ARRAYSIZE = SharingLog_QrCodeOpenedInWebClient_ClientPlatform_ClientPlatform_MAX + 1; + +const std::string& SharingLog_QrCodeOpenedInWebClient_ClientPlatform_Name(SharingLog_QrCodeOpenedInWebClient_ClientPlatform value); +template +inline const std::string& SharingLog_QrCodeOpenedInWebClient_ClientPlatform_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SharingLog_QrCodeOpenedInWebClient_ClientPlatform_Name."); + return SharingLog_QrCodeOpenedInWebClient_ClientPlatform_Name(static_cast(enum_t_value)); +} +bool SharingLog_QrCodeOpenedInWebClient_ClientPlatform_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SharingLog_QrCodeOpenedInWebClient_ClientPlatform* value); // =================================================================== class SharingLog_AppInfo final : @@ -729,6 +833,11 @@ class SharingLog_DeviceSettings final : kIsBtEnabledFieldNumber = 5, kIsLocationEnabledFieldNumber = 6, kIsWifiEnabledFieldNumber = 7, + kFirstSuccessfulTransferDateFieldNumber = 8, + kPreviousSuccessfulTransferDateFieldNumber = 9, + kLifetimeTransferCountFieldNumber = 10, + kContactAccessFieldNumber = 11, + kIdentityVerificationFieldNumber = 12, }; // optional .location.nearby.proto.sharing.Visibility visibility = 1; bool has_visibility() const; @@ -821,6 +930,71 @@ class SharingLog_DeviceSettings final : void _internal_set_is_wifi_enabled(bool value); public: + // optional int32 first_successful_transfer_date = 8; + bool has_first_successful_transfer_date() const; + private: + bool _internal_has_first_successful_transfer_date() const; + public: + void clear_first_successful_transfer_date(); + int32_t first_successful_transfer_date() const; + void set_first_successful_transfer_date(int32_t value); + private: + int32_t _internal_first_successful_transfer_date() const; + void _internal_set_first_successful_transfer_date(int32_t value); + public: + + // optional int32 previous_successful_transfer_date = 9; + bool has_previous_successful_transfer_date() const; + private: + bool _internal_has_previous_successful_transfer_date() const; + public: + void clear_previous_successful_transfer_date(); + int32_t previous_successful_transfer_date() const; + void set_previous_successful_transfer_date(int32_t value); + private: + int32_t _internal_previous_successful_transfer_date() const; + void _internal_set_previous_successful_transfer_date(int32_t value); + public: + + // optional int32 lifetime_transfer_count = 10; + bool has_lifetime_transfer_count() const; + private: + bool _internal_has_lifetime_transfer_count() const; + public: + void clear_lifetime_transfer_count(); + int32_t lifetime_transfer_count() const; + void set_lifetime_transfer_count(int32_t value); + private: + int32_t _internal_lifetime_transfer_count() const; + void _internal_set_lifetime_transfer_count(int32_t value); + public: + + // optional .location.nearby.proto.sharing.ContactAccess contact_access = 11; + bool has_contact_access() const; + private: + bool _internal_has_contact_access() const; + public: + void clear_contact_access(); + ::location::nearby::proto::sharing::ContactAccess contact_access() const; + void set_contact_access(::location::nearby::proto::sharing::ContactAccess value); + private: + ::location::nearby::proto::sharing::ContactAccess _internal_contact_access() const; + void _internal_set_contact_access(::location::nearby::proto::sharing::ContactAccess value); + public: + + // optional .location.nearby.proto.sharing.IdentityVerification identity_verification = 12; + bool has_identity_verification() const; + private: + bool _internal_has_identity_verification() const; + public: + void clear_identity_verification(); + ::location::nearby::proto::sharing::IdentityVerification identity_verification() const; + void set_identity_verification(::location::nearby::proto::sharing::IdentityVerification value); + private: + ::location::nearby::proto::sharing::IdentityVerification _internal_identity_verification() const; + void _internal_set_identity_verification(::location::nearby::proto::sharing::IdentityVerification value); + public: + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.DeviceSettings) private: class _Internal; @@ -837,6 +1011,11 @@ class SharingLog_DeviceSettings final : bool is_bt_enabled_; bool is_location_enabled_; bool is_wifi_enabled_; + int32_t first_successful_transfer_date_; + int32_t previous_successful_transfer_date_; + int32_t lifetime_transfer_count_; + int contact_access_; + int identity_verification_; friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -1267,6 +1446,7 @@ class SharingLog_EstablishConnection final : enum : int { kReferrerNameFieldNumber = 7, kShareTargetInfoFieldNumber = 6, + kQrCodeReceiverConnectLatencyFieldNumber = 10, kSessionIdFieldNumber = 2, kStatusFieldNumber = 1, kTransferPositionFieldNumber = 3, @@ -1311,6 +1491,24 @@ class SharingLog_EstablishConnection final : ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info); ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* unsafe_arena_release_share_target_info(); + // optional .google.protobuf.Duration qr_code_receiver_connect_latency = 10; + bool has_qr_code_receiver_connect_latency() const; + private: + bool _internal_has_qr_code_receiver_connect_latency() const; + public: + void clear_qr_code_receiver_connect_latency(); + const ::PROTOBUF_NAMESPACE_ID::Duration& qr_code_receiver_connect_latency() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Duration* release_qr_code_receiver_connect_latency(); + ::PROTOBUF_NAMESPACE_ID::Duration* mutable_qr_code_receiver_connect_latency(); + void set_allocated_qr_code_receiver_connect_latency(::PROTOBUF_NAMESPACE_ID::Duration* qr_code_receiver_connect_latency); + private: + const ::PROTOBUF_NAMESPACE_ID::Duration& _internal_qr_code_receiver_connect_latency() const; + ::PROTOBUF_NAMESPACE_ID::Duration* _internal_mutable_qr_code_receiver_connect_latency(); + public: + void unsafe_arena_set_allocated_qr_code_receiver_connect_latency( + ::PROTOBUF_NAMESPACE_ID::Duration* qr_code_receiver_connect_latency); + ::PROTOBUF_NAMESPACE_ID::Duration* unsafe_arena_release_qr_code_receiver_connect_latency(); + // optional int64 session_id = 2; bool has_session_id() const; private: @@ -1376,14 +1574,14 @@ class SharingLog_EstablishConnection final : void _internal_set_concurrent_connections(int32_t value); public: - // optional bool qr_code_flow = 8; - bool has_qr_code_flow() const; + // optional bool qr_code_flow = 8 [deprecated = true]; + PROTOBUF_DEPRECATED bool has_qr_code_flow() const; private: bool _internal_has_qr_code_flow() const; public: - void clear_qr_code_flow(); - bool qr_code_flow() const; - void set_qr_code_flow(bool value); + PROTOBUF_DEPRECATED void clear_qr_code_flow(); + PROTOBUF_DEPRECATED bool qr_code_flow() const; + PROTOBUF_DEPRECATED void set_qr_code_flow(bool value); private: bool _internal_qr_code_flow() const; void _internal_set_qr_code_flow(bool value); @@ -1413,6 +1611,7 @@ class SharingLog_EstablishConnection final : mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_name_; ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info_; + ::PROTOBUF_NAMESPACE_ID::Duration* qr_code_receiver_connect_latency_; int64_t session_id_; int status_; int32_t transfer_position_; @@ -2433,6 +2632,7 @@ class SharingLog_ScanForShareTargetsStart final : kStatusFieldNumber = 2, kScanTypeFieldNumber = 3, kFlowIdFieldNumber = 4, + kUseQrCodeFieldNumber = 6, }; // optional string referrer_name = 5; bool has_referrer_name() const; @@ -2504,6 +2704,19 @@ class SharingLog_ScanForShareTargetsStart final : void _internal_set_flow_id(int64_t value); public: + // optional bool use_qr_code = 6; + bool has_use_qr_code() const; + private: + bool _internal_has_use_qr_code() const; + public: + void clear_use_qr_code(); + bool use_qr_code() const; + void set_use_qr_code(bool value); + private: + bool _internal_use_qr_code() const; + void _internal_set_use_qr_code(bool value); + public: + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.ScanForShareTargetsStart) private: class _Internal; @@ -2518,6 +2731,7 @@ class SharingLog_ScanForShareTargetsStart final : int status_; int scan_type_; int64_t flow_id_; + bool use_qr_code_; friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -3715,6 +3929,10 @@ class SharingLog_EventMetadata final : // accessors ------------------------------------------------------- enum : int { + kCloudSharingIdFieldNumber = 8, + kCloudReceiverSessionIdFieldNumber = 9, + kExternalProviderNameFieldNumber = 10, + kExternalProviderIdFieldNumber = 11, kUseCaseFieldNumber = 1, kInitialOptInFieldNumber = 2, kOptInFieldNumber = 3, @@ -3723,6 +3941,78 @@ class SharingLog_EventMetadata final : kSessionIdFieldNumber = 6, kVendorIdFieldNumber = 7, }; + // optional string cloud_sharing_id = 8; + bool has_cloud_sharing_id() const; + private: + bool _internal_has_cloud_sharing_id() const; + public: + void clear_cloud_sharing_id(); + const std::string& cloud_sharing_id() const; + template + void set_cloud_sharing_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_cloud_sharing_id(); + PROTOBUF_NODISCARD std::string* release_cloud_sharing_id(); + void set_allocated_cloud_sharing_id(std::string* cloud_sharing_id); + private: + const std::string& _internal_cloud_sharing_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cloud_sharing_id(const std::string& value); + std::string* _internal_mutable_cloud_sharing_id(); + public: + + // optional string cloud_receiver_session_id = 9; + bool has_cloud_receiver_session_id() const; + private: + bool _internal_has_cloud_receiver_session_id() const; + public: + void clear_cloud_receiver_session_id(); + const std::string& cloud_receiver_session_id() const; + template + void set_cloud_receiver_session_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_cloud_receiver_session_id(); + PROTOBUF_NODISCARD std::string* release_cloud_receiver_session_id(); + void set_allocated_cloud_receiver_session_id(std::string* cloud_receiver_session_id); + private: + const std::string& _internal_cloud_receiver_session_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cloud_receiver_session_id(const std::string& value); + std::string* _internal_mutable_cloud_receiver_session_id(); + public: + + // optional string external_provider_name = 10; + bool has_external_provider_name() const; + private: + bool _internal_has_external_provider_name() const; + public: + void clear_external_provider_name(); + const std::string& external_provider_name() const; + template + void set_external_provider_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_external_provider_name(); + PROTOBUF_NODISCARD std::string* release_external_provider_name(); + void set_allocated_external_provider_name(std::string* external_provider_name); + private: + const std::string& _internal_external_provider_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_external_provider_name(const std::string& value); + std::string* _internal_mutable_external_provider_name(); + public: + + // optional string external_provider_id = 11; + bool has_external_provider_id() const; + private: + bool _internal_has_external_provider_id() const; + public: + void clear_external_provider_id(); + const std::string& external_provider_id() const; + template + void set_external_provider_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_external_provider_id(); + PROTOBUF_NODISCARD std::string* release_external_provider_id(); + void set_allocated_external_provider_id(std::string* external_provider_id); + private: + const std::string& _internal_external_provider_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_external_provider_id(const std::string& value); + std::string* _internal_mutable_external_provider_id(); + public: + // optional .location.nearby.proto.sharing.SharingUseCase use_case = 1; bool has_use_case() const; private: @@ -3736,40 +4026,40 @@ class SharingLog_EventMetadata final : void _internal_set_use_case(::location::nearby::proto::sharing::SharingUseCase value); public: - // optional bool initial_opt_in = 2; - bool has_initial_opt_in() const; + // optional bool initial_opt_in = 2 [deprecated = true]; + PROTOBUF_DEPRECATED bool has_initial_opt_in() const; private: bool _internal_has_initial_opt_in() const; public: - void clear_initial_opt_in(); - bool initial_opt_in() const; - void set_initial_opt_in(bool value); + PROTOBUF_DEPRECATED void clear_initial_opt_in(); + PROTOBUF_DEPRECATED bool initial_opt_in() const; + PROTOBUF_DEPRECATED void set_initial_opt_in(bool value); private: bool _internal_initial_opt_in() const; void _internal_set_initial_opt_in(bool value); public: - // optional bool opt_in = 3; - bool has_opt_in() const; + // optional bool opt_in = 3 [deprecated = true]; + PROTOBUF_DEPRECATED bool has_opt_in() const; private: bool _internal_has_opt_in() const; public: - void clear_opt_in(); - bool opt_in() const; - void set_opt_in(bool value); + PROTOBUF_DEPRECATED void clear_opt_in(); + PROTOBUF_DEPRECATED bool opt_in() const; + PROTOBUF_DEPRECATED void set_opt_in(bool value); private: bool _internal_opt_in() const; void _internal_set_opt_in(bool value); public: - // optional bool initial_enable_status = 4; - bool has_initial_enable_status() const; + // optional bool initial_enable_status = 4 [deprecated = true]; + PROTOBUF_DEPRECATED bool has_initial_enable_status() const; private: bool _internal_has_initial_enable_status() const; public: - void clear_initial_enable_status(); - bool initial_enable_status() const; - void set_initial_enable_status(bool value); + PROTOBUF_DEPRECATED void clear_initial_enable_status(); + PROTOBUF_DEPRECATED bool initial_enable_status() const; + PROTOBUF_DEPRECATED void set_initial_enable_status(bool value); private: bool _internal_initial_enable_status() const; void _internal_set_initial_enable_status(bool value); @@ -3823,6 +4113,10 @@ class SharingLog_EventMetadata final : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cloud_sharing_id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cloud_receiver_session_id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr external_provider_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr external_provider_id_; int use_case_; bool initial_opt_in_; bool opt_in_; @@ -3948,6 +4242,7 @@ class SharingLog_DiscoverShareTarget final : enum : int { kReferrerNameFieldNumber = 5, + kCloudReceiverSessionIdFieldNumber = 8, kShareTargetInfoFieldNumber = 1, kDurationSinceScanningFieldNumber = 2, kSessionIdFieldNumber = 3, @@ -3973,6 +4268,24 @@ class SharingLog_DiscoverShareTarget final : std::string* _internal_mutable_referrer_name(); public: + // optional string cloud_receiver_session_id = 8; + bool has_cloud_receiver_session_id() const; + private: + bool _internal_has_cloud_receiver_session_id() const; + public: + void clear_cloud_receiver_session_id(); + const std::string& cloud_receiver_session_id() const; + template + void set_cloud_receiver_session_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_cloud_receiver_session_id(); + PROTOBUF_NODISCARD std::string* release_cloud_receiver_session_id(); + void set_allocated_cloud_receiver_session_id(std::string* cloud_receiver_session_id); + private: + const std::string& _internal_cloud_receiver_session_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cloud_receiver_session_id(const std::string& value); + std::string* _internal_mutable_cloud_receiver_session_id(); + public: + // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; bool has_share_target_info() const; private: @@ -4071,6 +4384,7 @@ class SharingLog_DiscoverShareTarget final : ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referrer_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cloud_receiver_session_id_; ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info_; ::PROTOBUF_NAMESPACE_ID::Duration* duration_since_scanning_; int64_t session_id_; @@ -4492,6 +4806,7 @@ class SharingLog_DescribeAttachments final : enum : int { kAttachmentsInfoFieldNumber = 1, + kDownloadDurationFieldNumber = 2, }; // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; bool has_attachments_info() const; @@ -4511,6 +4826,24 @@ class SharingLog_DescribeAttachments final : ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info); ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* unsafe_arena_release_attachments_info(); + // optional .google.protobuf.Duration download_duration = 2; + bool has_download_duration() const; + private: + bool _internal_has_download_duration() const; + public: + void clear_download_duration(); + const ::PROTOBUF_NAMESPACE_ID::Duration& download_duration() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Duration* release_download_duration(); + ::PROTOBUF_NAMESPACE_ID::Duration* mutable_download_duration(); + void set_allocated_download_duration(::PROTOBUF_NAMESPACE_ID::Duration* download_duration); + private: + const ::PROTOBUF_NAMESPACE_ID::Duration& _internal_download_duration() const; + ::PROTOBUF_NAMESPACE_ID::Duration* _internal_mutable_download_duration(); + public: + void unsafe_arena_set_allocated_download_duration( + ::PROTOBUF_NAMESPACE_ID::Duration* download_duration); + ::PROTOBUF_NAMESPACE_ID::Duration* unsafe_arena_release_download_duration(); + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.DescribeAttachments) private: class _Internal; @@ -4521,6 +4854,7 @@ class SharingLog_DescribeAttachments final : ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info_; + ::PROTOBUF_NAMESPACE_ID::Duration* download_duration_; friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -5185,10 +5519,13 @@ class SharingLog_SendAttachmentsStart final : enum : int { kAttachmentsInfoFieldNumber = 2, + kShareTargetInfoFieldNumber = 6, kSessionIdFieldNumber = 1, kTransferPositionFieldNumber = 3, kConcurrentConnectionsFieldNumber = 4, kQrCodeFlowFieldNumber = 5, + kAdvancedProtectionEnabledFieldNumber = 7, + kAdvancedProtectionMismatchFieldNumber = 8, }; // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 2; bool has_attachments_info() const; @@ -5208,6 +5545,24 @@ class SharingLog_SendAttachmentsStart final : ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info); ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* unsafe_arena_release_attachments_info(); + // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 6; + bool has_share_target_info() const; + private: + bool _internal_has_share_target_info() const; + public: + void clear_share_target_info(); + const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& share_target_info() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* release_share_target_info(); + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* mutable_share_target_info(); + void set_allocated_share_target_info(::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info); + private: + const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& _internal_share_target_info() const; + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* _internal_mutable_share_target_info(); + public: + void unsafe_arena_set_allocated_share_target_info( + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info); + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* unsafe_arena_release_share_target_info(); + // optional int64 session_id = 1; bool has_session_id() const; private: @@ -5247,19 +5602,45 @@ class SharingLog_SendAttachmentsStart final : void _internal_set_concurrent_connections(int32_t value); public: - // optional bool qr_code_flow = 5; - bool has_qr_code_flow() const; + // optional bool qr_code_flow = 5 [deprecated = true]; + PROTOBUF_DEPRECATED bool has_qr_code_flow() const; private: bool _internal_has_qr_code_flow() const; public: - void clear_qr_code_flow(); - bool qr_code_flow() const; - void set_qr_code_flow(bool value); + PROTOBUF_DEPRECATED void clear_qr_code_flow(); + PROTOBUF_DEPRECATED bool qr_code_flow() const; + PROTOBUF_DEPRECATED void set_qr_code_flow(bool value); private: bool _internal_qr_code_flow() const; void _internal_set_qr_code_flow(bool value); public: + // optional bool advanced_protection_enabled = 7; + bool has_advanced_protection_enabled() const; + private: + bool _internal_has_advanced_protection_enabled() const; + public: + void clear_advanced_protection_enabled(); + bool advanced_protection_enabled() const; + void set_advanced_protection_enabled(bool value); + private: + bool _internal_advanced_protection_enabled() const; + void _internal_set_advanced_protection_enabled(bool value); + public: + + // optional bool advanced_protection_mismatch = 8; + bool has_advanced_protection_mismatch() const; + private: + bool _internal_has_advanced_protection_mismatch() const; + public: + void clear_advanced_protection_mismatch(); + bool advanced_protection_mismatch() const; + void set_advanced_protection_mismatch(bool value); + private: + bool _internal_advanced_protection_mismatch() const; + void _internal_set_advanced_protection_mismatch(bool value); + public: + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart) private: class _Internal; @@ -5270,10 +5651,13 @@ class SharingLog_SendAttachmentsStart final : ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info_; + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info_; int64_t session_id_; int32_t transfer_position_; int32_t concurrent_connections_; bool qr_code_flow_; + bool advanced_protection_enabled_; + bool advanced_protection_mismatch_; friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -5401,6 +5785,12 @@ class SharingLog_SendAttachmentsEnd final : kDurationMillisFieldNumber = 7, kConcurrentConnectionsFieldNumber = 5, kConnectionLayerStatusFieldNumber = 10, + kFirstSuccessfulTransferDateFieldNumber = 11, + kPreviousSuccessfulTransferDateFieldNumber = 12, + kLifetimeTransferCountFieldNumber = 13, + kConnectionMediumFieldNumber = 14, + kDataUsageFieldNumber = 15, + kIsMutualContactFieldNumber = 16, }; // optional string referrer_name = 9; bool has_referrer_name() const; @@ -5547,6 +5937,84 @@ class SharingLog_SendAttachmentsEnd final : void _internal_set_connection_layer_status(::location::nearby::proto::sharing::ConnectionLayerStatus value); public: + // optional int32 first_successful_transfer_date = 11; + bool has_first_successful_transfer_date() const; + private: + bool _internal_has_first_successful_transfer_date() const; + public: + void clear_first_successful_transfer_date(); + int32_t first_successful_transfer_date() const; + void set_first_successful_transfer_date(int32_t value); + private: + int32_t _internal_first_successful_transfer_date() const; + void _internal_set_first_successful_transfer_date(int32_t value); + public: + + // optional int32 previous_successful_transfer_date = 12; + bool has_previous_successful_transfer_date() const; + private: + bool _internal_has_previous_successful_transfer_date() const; + public: + void clear_previous_successful_transfer_date(); + int32_t previous_successful_transfer_date() const; + void set_previous_successful_transfer_date(int32_t value); + private: + int32_t _internal_previous_successful_transfer_date() const; + void _internal_set_previous_successful_transfer_date(int32_t value); + public: + + // optional int32 lifetime_transfer_count = 13; + bool has_lifetime_transfer_count() const; + private: + bool _internal_has_lifetime_transfer_count() const; + public: + void clear_lifetime_transfer_count(); + int32_t lifetime_transfer_count() const; + void set_lifetime_transfer_count(int32_t value); + private: + int32_t _internal_lifetime_transfer_count() const; + void _internal_set_lifetime_transfer_count(int32_t value); + public: + + // optional int32 connection_medium = 14; + bool has_connection_medium() const; + private: + bool _internal_has_connection_medium() const; + public: + void clear_connection_medium(); + int32_t connection_medium() const; + void set_connection_medium(int32_t value); + private: + int32_t _internal_connection_medium() const; + void _internal_set_connection_medium(int32_t value); + public: + + // optional .location.nearby.proto.sharing.DataUsage data_usage = 15; + bool has_data_usage() const; + private: + bool _internal_has_data_usage() const; + public: + void clear_data_usage(); + ::location::nearby::proto::sharing::DataUsage data_usage() const; + void set_data_usage(::location::nearby::proto::sharing::DataUsage value); + private: + ::location::nearby::proto::sharing::DataUsage _internal_data_usage() const; + void _internal_set_data_usage(::location::nearby::proto::sharing::DataUsage value); + public: + + // optional bool is_mutual_contact = 16; + bool has_is_mutual_contact() const; + private: + bool _internal_has_is_mutual_contact() const; + public: + void clear_is_mutual_contact(); + bool is_mutual_contact() const; + void set_is_mutual_contact(bool value); + private: + bool _internal_is_mutual_contact() const; + void _internal_set_is_mutual_contact(bool value); + public: + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd) private: class _Internal; @@ -5566,6 +6034,12 @@ class SharingLog_SendAttachmentsEnd final : int64_t duration_millis_; int32_t concurrent_connections_; int connection_layer_status_; + int32_t first_successful_transfer_date_; + int32_t previous_successful_transfer_date_; + int32_t lifetime_transfer_count_; + int32_t connection_medium_; + int data_usage_; + bool is_mutual_contact_; friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -5870,6 +6344,11 @@ class SharingLog_ReceiveAttachmentsEnd final : kSessionIdFieldNumber = 1, kReceivedBytesFieldNumber = 2, kStatusFieldNumber = 3, + kFirstSuccessfulTransferDateFieldNumber = 6, + kPreviousSuccessfulTransferDateFieldNumber = 7, + kLifetimeTransferCountFieldNumber = 8, + kConnectionMediumFieldNumber = 14, + kDataUsageFieldNumber = 15, }; // optional string referrer_name = 4; bool has_referrer_name() const; @@ -5946,6 +6425,71 @@ class SharingLog_ReceiveAttachmentsEnd final : void _internal_set_status(::location::nearby::proto::sharing::AttachmentTransmissionStatus value); public: + // optional int32 first_successful_transfer_date = 6; + bool has_first_successful_transfer_date() const; + private: + bool _internal_has_first_successful_transfer_date() const; + public: + void clear_first_successful_transfer_date(); + int32_t first_successful_transfer_date() const; + void set_first_successful_transfer_date(int32_t value); + private: + int32_t _internal_first_successful_transfer_date() const; + void _internal_set_first_successful_transfer_date(int32_t value); + public: + + // optional int32 previous_successful_transfer_date = 7; + bool has_previous_successful_transfer_date() const; + private: + bool _internal_has_previous_successful_transfer_date() const; + public: + void clear_previous_successful_transfer_date(); + int32_t previous_successful_transfer_date() const; + void set_previous_successful_transfer_date(int32_t value); + private: + int32_t _internal_previous_successful_transfer_date() const; + void _internal_set_previous_successful_transfer_date(int32_t value); + public: + + // optional int32 lifetime_transfer_count = 8; + bool has_lifetime_transfer_count() const; + private: + bool _internal_has_lifetime_transfer_count() const; + public: + void clear_lifetime_transfer_count(); + int32_t lifetime_transfer_count() const; + void set_lifetime_transfer_count(int32_t value); + private: + int32_t _internal_lifetime_transfer_count() const; + void _internal_set_lifetime_transfer_count(int32_t value); + public: + + // optional int32 connection_medium = 14; + bool has_connection_medium() const; + private: + bool _internal_has_connection_medium() const; + public: + void clear_connection_medium(); + int32_t connection_medium() const; + void set_connection_medium(int32_t value); + private: + int32_t _internal_connection_medium() const; + void _internal_set_connection_medium(int32_t value); + public: + + // optional .location.nearby.proto.sharing.DataUsage data_usage = 15; + bool has_data_usage() const; + private: + bool _internal_has_data_usage() const; + public: + void clear_data_usage(); + ::location::nearby::proto::sharing::DataUsage data_usage() const; + void set_data_usage(::location::nearby::proto::sharing::DataUsage value); + private: + ::location::nearby::proto::sharing::DataUsage _internal_data_usage() const; + void _internal_set_data_usage(::location::nearby::proto::sharing::DataUsage value); + public: + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd) private: class _Internal; @@ -5960,6 +6504,11 @@ class SharingLog_ReceiveAttachmentsEnd final : int64_t session_id_; int64_t received_bytes_; int status_; + int32_t first_successful_transfer_date_; + int32_t previous_successful_transfer_date_; + int32_t lifetime_transfer_count_; + int32_t connection_medium_; + int data_usage_; friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -11194,6 +11743,8 @@ class SharingLog_ShareTargetInfo final : kDeviceTypeFieldNumber = 1, kOsTypeFieldNumber = 2, kDeviceRelationshipFieldNumber = 3, + kHasMatchingQrCodeFieldNumber = 4, + kIsExternalFieldNumber = 5, }; // optional .location.nearby.proto.sharing.DeviceType device_type = 1; bool has_device_type() const; @@ -11234,6 +11785,32 @@ class SharingLog_ShareTargetInfo final : void _internal_set_device_relationship(::location::nearby::proto::sharing::DeviceRelationship value); public: + // optional bool has_matching_qr_code = 4; + bool has_has_matching_qr_code() const; + private: + bool _internal_has_has_matching_qr_code() const; + public: + void clear_has_matching_qr_code(); + bool has_matching_qr_code() const; + void set_has_matching_qr_code(bool value); + private: + bool _internal_has_matching_qr_code() const; + void _internal_set_has_matching_qr_code(bool value); + public: + + // optional bool is_external = 5; + bool has_is_external() const; + private: + bool _internal_has_is_external() const; + public: + void clear_is_external(); + bool is_external() const; + void set_is_external(bool value); + private: + bool _internal_is_external() const; + void _internal_set_is_external(bool value); + public: + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo) private: class _Internal; @@ -11246,6 +11823,8 @@ class SharingLog_ShareTargetInfo final : int device_type_; int os_type_; int device_relationship_; + bool has_matching_qr_code_; + bool is_external_; friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -11837,6 +12416,8 @@ class SharingLog_FileAttachment final : SharingLog_FileAttachment_Type_AUDIO; static constexpr Type DOCUMENT = SharingLog_FileAttachment_Type_DOCUMENT; + static constexpr Type CONTACT_CARD = + SharingLog_FileAttachment_Type_CONTACT_CARD; static inline bool Type_IsValid(int value) { return SharingLog_FileAttachment_Type_IsValid(value); } @@ -12491,6 +13072,303 @@ class SharingLog_StreamAttachment final : }; // ------------------------------------------------------------------- +class SharingLog_CloudAttachmentInfo final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) */ { + public: + inline SharingLog_CloudAttachmentInfo() : SharingLog_CloudAttachmentInfo(nullptr) {} + ~SharingLog_CloudAttachmentInfo() override; + explicit constexpr SharingLog_CloudAttachmentInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_CloudAttachmentInfo(const SharingLog_CloudAttachmentInfo& from); + SharingLog_CloudAttachmentInfo(SharingLog_CloudAttachmentInfo&& from) noexcept + : SharingLog_CloudAttachmentInfo() { + *this = ::std::move(from); + } + + inline SharingLog_CloudAttachmentInfo& operator=(const SharingLog_CloudAttachmentInfo& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_CloudAttachmentInfo& operator=(SharingLog_CloudAttachmentInfo&& 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 SharingLog_CloudAttachmentInfo& default_instance() { + return *internal_default_instance(); + } + enum CloudAttachmentCase { + kTextAttachment = 2, + kFileAttachment = 3, + kWifiCredentialsAttachment = 4, + kAppAttachment = 5, + kStreamAttachment = 6, + CLOUDATTACHMENT_NOT_SET = 0, + }; + + static inline const SharingLog_CloudAttachmentInfo* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_CloudAttachmentInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 72; + + friend void swap(SharingLog_CloudAttachmentInfo& a, SharingLog_CloudAttachmentInfo& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_CloudAttachmentInfo* 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(SharingLog_CloudAttachmentInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_CloudAttachmentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_CloudAttachmentInfo& from); + void MergeFrom(const SharingLog_CloudAttachmentInfo& 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(SharingLog_CloudAttachmentInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo"; + } + protected: + explicit SharingLog_CloudAttachmentInfo(::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 { + kStatusFieldNumber = 1, + kTransferredBytesFieldNumber = 7, + kDurationMillisFieldNumber = 8, + kTextAttachmentFieldNumber = 2, + kFileAttachmentFieldNumber = 3, + kWifiCredentialsAttachmentFieldNumber = 4, + kAppAttachmentFieldNumber = 5, + kStreamAttachmentFieldNumber = 6, + }; + // optional .location.nearby.proto.sharing.AttachmentTransmissionStatus status = 1; + bool has_status() const; + private: + bool _internal_has_status() const; + public: + void clear_status(); + ::location::nearby::proto::sharing::AttachmentTransmissionStatus status() const; + void set_status(::location::nearby::proto::sharing::AttachmentTransmissionStatus value); + private: + ::location::nearby::proto::sharing::AttachmentTransmissionStatus _internal_status() const; + void _internal_set_status(::location::nearby::proto::sharing::AttachmentTransmissionStatus value); + public: + + // optional int64 transferred_bytes = 7; + bool has_transferred_bytes() const; + private: + bool _internal_has_transferred_bytes() const; + public: + void clear_transferred_bytes(); + int64_t transferred_bytes() const; + void set_transferred_bytes(int64_t value); + private: + int64_t _internal_transferred_bytes() const; + void _internal_set_transferred_bytes(int64_t value); + public: + + // optional int64 duration_millis = 8; + bool has_duration_millis() const; + private: + bool _internal_has_duration_millis() const; + public: + void clear_duration_millis(); + int64_t duration_millis() const; + void set_duration_millis(int64_t value); + private: + int64_t _internal_duration_millis() const; + void _internal_set_duration_millis(int64_t value); + public: + + // .nearby.sharing.analytics.proto.SharingLog.TextAttachment text_attachment = 2; + bool has_text_attachment() const; + private: + bool _internal_has_text_attachment() const; + public: + void clear_text_attachment(); + const ::nearby::sharing::analytics::proto::SharingLog_TextAttachment& text_attachment() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* release_text_attachment(); + ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* mutable_text_attachment(); + void set_allocated_text_attachment(::nearby::sharing::analytics::proto::SharingLog_TextAttachment* text_attachment); + private: + const ::nearby::sharing::analytics::proto::SharingLog_TextAttachment& _internal_text_attachment() const; + ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* _internal_mutable_text_attachment(); + public: + void unsafe_arena_set_allocated_text_attachment( + ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* text_attachment); + ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* unsafe_arena_release_text_attachment(); + + // .nearby.sharing.analytics.proto.SharingLog.FileAttachment file_attachment = 3; + bool has_file_attachment() const; + private: + bool _internal_has_file_attachment() const; + public: + void clear_file_attachment(); + const ::nearby::sharing::analytics::proto::SharingLog_FileAttachment& file_attachment() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* release_file_attachment(); + ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* mutable_file_attachment(); + void set_allocated_file_attachment(::nearby::sharing::analytics::proto::SharingLog_FileAttachment* file_attachment); + private: + const ::nearby::sharing::analytics::proto::SharingLog_FileAttachment& _internal_file_attachment() const; + ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* _internal_mutable_file_attachment(); + public: + void unsafe_arena_set_allocated_file_attachment( + ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* file_attachment); + ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* unsafe_arena_release_file_attachment(); + + // .nearby.sharing.analytics.proto.SharingLog.WifiCredentialsAttachment wifi_credentials_attachment = 4; + bool has_wifi_credentials_attachment() const; + private: + bool _internal_has_wifi_credentials_attachment() const; + public: + void clear_wifi_credentials_attachment(); + const ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment& wifi_credentials_attachment() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* release_wifi_credentials_attachment(); + ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* mutable_wifi_credentials_attachment(); + void set_allocated_wifi_credentials_attachment(::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* wifi_credentials_attachment); + private: + const ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment& _internal_wifi_credentials_attachment() const; + ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* _internal_mutable_wifi_credentials_attachment(); + public: + void unsafe_arena_set_allocated_wifi_credentials_attachment( + ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* wifi_credentials_attachment); + ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* unsafe_arena_release_wifi_credentials_attachment(); + + // .nearby.sharing.analytics.proto.SharingLog.AppAttachment app_attachment = 5; + bool has_app_attachment() const; + private: + bool _internal_has_app_attachment() const; + public: + void clear_app_attachment(); + const ::nearby::sharing::analytics::proto::SharingLog_AppAttachment& app_attachment() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* release_app_attachment(); + ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* mutable_app_attachment(); + void set_allocated_app_attachment(::nearby::sharing::analytics::proto::SharingLog_AppAttachment* app_attachment); + private: + const ::nearby::sharing::analytics::proto::SharingLog_AppAttachment& _internal_app_attachment() const; + ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* _internal_mutable_app_attachment(); + public: + void unsafe_arena_set_allocated_app_attachment( + ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* app_attachment); + ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* unsafe_arena_release_app_attachment(); + + // .nearby.sharing.analytics.proto.SharingLog.StreamAttachment stream_attachment = 6; + bool has_stream_attachment() const; + private: + bool _internal_has_stream_attachment() const; + public: + void clear_stream_attachment(); + const ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment& stream_attachment() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* release_stream_attachment(); + ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* mutable_stream_attachment(); + void set_allocated_stream_attachment(::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* stream_attachment); + private: + const ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment& _internal_stream_attachment() const; + ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* _internal_mutable_stream_attachment(); + public: + void unsafe_arena_set_allocated_stream_attachment( + ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* stream_attachment); + ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* unsafe_arena_release_stream_attachment(); + + void clear_CloudAttachment(); + CloudAttachmentCase CloudAttachment_case() const; + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo) + private: + class _Internal; + void set_has_text_attachment(); + void set_has_file_attachment(); + void set_has_wifi_credentials_attachment(); + void set_has_app_attachment(); + void set_has_stream_attachment(); + + inline bool has_CloudAttachment() const; + inline void clear_has_CloudAttachment(); + + 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_; + int status_; + int64_t transferred_bytes_; + int64_t duration_millis_; + union CloudAttachmentUnion { + constexpr CloudAttachmentUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* text_attachment_; + ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* file_attachment_; + ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* wifi_credentials_attachment_; + ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* app_attachment_; + ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* stream_attachment_; + } CloudAttachment_; + uint32_t _oneof_case_[1]; + + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + class SharingLog_AppCrash final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.AppCrash) */ { public: @@ -12537,7 +13415,7 @@ class SharingLog_AppCrash final : &_SharingLog_AppCrash_default_instance_); } static constexpr int kIndexInFileMessages = - 72; + 73; friend void swap(SharingLog_AppCrash& a, SharingLog_AppCrash& b) { a.Swap(&b); @@ -12679,7 +13557,7 @@ class SharingLog_SetupWizard final : &_SharingLog_SetupWizard_default_instance_); } static constexpr int kIndexInFileMessages = - 73; + 74; friend void swap(SharingLog_SetupWizard& a, SharingLog_SetupWizard& b) { a.Swap(&b); @@ -12747,6 +13625,7 @@ class SharingLog_SetupWizard final : enum : int { kVisibilityFieldNumber = 1, + kPreviousVisibilityFieldNumber = 2, }; // optional .location.nearby.proto.sharing.Visibility visibility = 1; bool has_visibility() const; @@ -12761,6 +13640,19 @@ class SharingLog_SetupWizard final : void _internal_set_visibility(::location::nearby::proto::sharing::Visibility value); public: + // optional .location.nearby.proto.sharing.Visibility previous_visibility = 2; + bool has_previous_visibility() const; + private: + bool _internal_has_previous_visibility() const; + public: + void clear_previous_visibility(); + ::location::nearby::proto::sharing::Visibility previous_visibility() const; + void set_previous_visibility(::location::nearby::proto::sharing::Visibility value); + private: + ::location::nearby::proto::sharing::Visibility _internal_previous_visibility() const; + void _internal_set_previous_visibility(::location::nearby::proto::sharing::Visibility value); + public: + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.SetupWizard) private: class _Internal; @@ -12771,6 +13663,7 @@ class SharingLog_SetupWizard final : ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; int visibility_; + int previous_visibility_; friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; }; // ------------------------------------------------------------------- @@ -12821,7 +13714,7 @@ class SharingLog_SendDesktopNotification final : &_SharingLog_SendDesktopNotification_default_instance_); } static constexpr int kIndexInFileMessages = - 74; + 75; friend void swap(SharingLog_SendDesktopNotification& a, SharingLog_SendDesktopNotification& b) { a.Swap(&b); @@ -12963,7 +13856,7 @@ class SharingLog_SendDesktopTransferEvent final : &_SharingLog_SendDesktopTransferEvent_default_instance_); } static constexpr int kIndexInFileMessages = - 75; + 76; friend void swap(SharingLog_SendDesktopTransferEvent& a, SharingLog_SendDesktopTransferEvent& b) { a.Swap(&b); @@ -13059,6 +13952,2388 @@ class SharingLog_SendDesktopTransferEvent final : }; // ------------------------------------------------------------------- +class SharingLog_ShowWaitingForAccept final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) */ { + public: + inline SharingLog_ShowWaitingForAccept() : SharingLog_ShowWaitingForAccept(nullptr) {} + ~SharingLog_ShowWaitingForAccept() override; + explicit constexpr SharingLog_ShowWaitingForAccept(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_ShowWaitingForAccept(const SharingLog_ShowWaitingForAccept& from); + SharingLog_ShowWaitingForAccept(SharingLog_ShowWaitingForAccept&& from) noexcept + : SharingLog_ShowWaitingForAccept() { + *this = ::std::move(from); + } + + inline SharingLog_ShowWaitingForAccept& operator=(const SharingLog_ShowWaitingForAccept& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_ShowWaitingForAccept& operator=(SharingLog_ShowWaitingForAccept&& 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 SharingLog_ShowWaitingForAccept& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_ShowWaitingForAccept* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_ShowWaitingForAccept_default_instance_); + } + static constexpr int kIndexInFileMessages = + 77; + + friend void swap(SharingLog_ShowWaitingForAccept& a, SharingLog_ShowWaitingForAccept& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_ShowWaitingForAccept* 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(SharingLog_ShowWaitingForAccept* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_ShowWaitingForAccept* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_ShowWaitingForAccept& from); + void MergeFrom(const SharingLog_ShowWaitingForAccept& 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(SharingLog_ShowWaitingForAccept* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept"; + } + protected: + explicit SharingLog_ShowWaitingForAccept(::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 { + kButtonStatusFieldNumber = 1, + }; + // optional .location.nearby.proto.sharing.ButtonStatus button_status = 1; + bool has_button_status() const; + private: + bool _internal_has_button_status() const; + public: + void clear_button_status(); + ::location::nearby::proto::sharing::ButtonStatus button_status() const; + void set_button_status(::location::nearby::proto::sharing::ButtonStatus value); + private: + ::location::nearby::proto::sharing::ButtonStatus _internal_button_status() const; + void _internal_set_button_status(::location::nearby::proto::sharing::ButtonStatus value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept) + 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_; + int button_status_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_HighQualityMediumSetup final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) */ { + public: + inline SharingLog_HighQualityMediumSetup() : SharingLog_HighQualityMediumSetup(nullptr) {} + ~SharingLog_HighQualityMediumSetup() override; + explicit constexpr SharingLog_HighQualityMediumSetup(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_HighQualityMediumSetup(const SharingLog_HighQualityMediumSetup& from); + SharingLog_HighQualityMediumSetup(SharingLog_HighQualityMediumSetup&& from) noexcept + : SharingLog_HighQualityMediumSetup() { + *this = ::std::move(from); + } + + inline SharingLog_HighQualityMediumSetup& operator=(const SharingLog_HighQualityMediumSetup& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_HighQualityMediumSetup& operator=(SharingLog_HighQualityMediumSetup&& 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 SharingLog_HighQualityMediumSetup& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_HighQualityMediumSetup* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_HighQualityMediumSetup_default_instance_); + } + static constexpr int kIndexInFileMessages = + 78; + + friend void swap(SharingLog_HighQualityMediumSetup& a, SharingLog_HighQualityMediumSetup& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_HighQualityMediumSetup* 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(SharingLog_HighQualityMediumSetup* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_HighQualityMediumSetup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_HighQualityMediumSetup& from); + void MergeFrom(const SharingLog_HighQualityMediumSetup& 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(SharingLog_HighQualityMediumSetup* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup"; + } + protected: + explicit SharingLog_HighQualityMediumSetup(::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 { + kShareTargetInfoFieldNumber = 1, + kSessionIdFieldNumber = 2, + kDurationMillisFieldNumber = 3, + kIsTimeoutFieldNumber = 4, + kOriginalQualityFieldNumber = 5, + kConnectionMediumFieldNumber = 6, + kConnectionModeFieldNumber = 7, + kInstantConnectionResultFieldNumber = 8, + }; + // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; + bool has_share_target_info() const; + private: + bool _internal_has_share_target_info() const; + public: + void clear_share_target_info(); + const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& share_target_info() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* release_share_target_info(); + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* mutable_share_target_info(); + void set_allocated_share_target_info(::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info); + private: + const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& _internal_share_target_info() const; + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* _internal_mutable_share_target_info(); + public: + void unsafe_arena_set_allocated_share_target_info( + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info); + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* unsafe_arena_release_share_target_info(); + + // optional int64 session_id = 2; + bool has_session_id() const; + private: + bool _internal_has_session_id() const; + public: + void clear_session_id(); + int64_t session_id() const; + void set_session_id(int64_t value); + private: + int64_t _internal_session_id() const; + void _internal_set_session_id(int64_t value); + public: + + // optional int64 duration_millis = 3; + bool has_duration_millis() const; + private: + bool _internal_has_duration_millis() const; + public: + void clear_duration_millis(); + int64_t duration_millis() const; + void set_duration_millis(int64_t value); + private: + int64_t _internal_duration_millis() const; + void _internal_set_duration_millis(int64_t value); + public: + + // optional bool is_timeout = 4; + bool has_is_timeout() const; + private: + bool _internal_has_is_timeout() const; + public: + void clear_is_timeout(); + bool is_timeout() const; + void set_is_timeout(bool value); + private: + bool _internal_is_timeout() const; + void _internal_set_is_timeout(bool value); + public: + + // optional int32 original_quality = 5; + bool has_original_quality() const; + private: + bool _internal_has_original_quality() const; + public: + void clear_original_quality(); + int32_t original_quality() const; + void set_original_quality(int32_t value); + private: + int32_t _internal_original_quality() const; + void _internal_set_original_quality(int32_t value); + public: + + // optional int32 connection_medium = 6; + bool has_connection_medium() const; + private: + bool _internal_has_connection_medium() const; + public: + void clear_connection_medium(); + int32_t connection_medium() const; + void set_connection_medium(int32_t value); + private: + int32_t _internal_connection_medium() const; + void _internal_set_connection_medium(int32_t value); + public: + + // optional int32 connection_mode = 7; + bool has_connection_mode() const; + private: + bool _internal_has_connection_mode() const; + public: + void clear_connection_mode(); + int32_t connection_mode() const; + void set_connection_mode(int32_t value); + private: + int32_t _internal_connection_mode() const; + void _internal_set_connection_mode(int32_t value); + public: + + // optional int32 instant_connection_result = 8; + bool has_instant_connection_result() const; + private: + bool _internal_has_instant_connection_result() const; + public: + void clear_instant_connection_result(); + int32_t instant_connection_result() const; + void set_instant_connection_result(int32_t value); + private: + int32_t _internal_instant_connection_result() const; + void _internal_set_instant_connection_result(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup) + 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_; + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info_; + int64_t session_id_; + int64_t duration_millis_; + bool is_timeout_; + int32_t original_quality_; + int32_t connection_medium_; + int32_t connection_mode_; + int32_t instant_connection_result_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_RpcCallStatus final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) */ { + public: + inline SharingLog_RpcCallStatus() : SharingLog_RpcCallStatus(nullptr) {} + ~SharingLog_RpcCallStatus() override; + explicit constexpr SharingLog_RpcCallStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_RpcCallStatus(const SharingLog_RpcCallStatus& from); + SharingLog_RpcCallStatus(SharingLog_RpcCallStatus&& from) noexcept + : SharingLog_RpcCallStatus() { + *this = ::std::move(from); + } + + inline SharingLog_RpcCallStatus& operator=(const SharingLog_RpcCallStatus& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_RpcCallStatus& operator=(SharingLog_RpcCallStatus&& 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 SharingLog_RpcCallStatus& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_RpcCallStatus* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_RpcCallStatus_default_instance_); + } + static constexpr int kIndexInFileMessages = + 79; + + friend void swap(SharingLog_RpcCallStatus& a, SharingLog_RpcCallStatus& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_RpcCallStatus* 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(SharingLog_RpcCallStatus* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_RpcCallStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_RpcCallStatus& from); + void MergeFrom(const SharingLog_RpcCallStatus& 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(SharingLog_RpcCallStatus* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.RpcCallStatus"; + } + protected: + explicit SharingLog_RpcCallStatus(::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 SharingLog_RpcCallStatus_RpcDirection RpcDirection; + static constexpr RpcDirection UNKNOWN_RPC_DIRECTION = + SharingLog_RpcCallStatus_RpcDirection_UNKNOWN_RPC_DIRECTION; + static constexpr RpcDirection INCOMING = + SharingLog_RpcCallStatus_RpcDirection_INCOMING; + static constexpr RpcDirection OUTGOING = + SharingLog_RpcCallStatus_RpcDirection_OUTGOING; + static inline bool RpcDirection_IsValid(int value) { + return SharingLog_RpcCallStatus_RpcDirection_IsValid(value); + } + static constexpr RpcDirection RpcDirection_MIN = + SharingLog_RpcCallStatus_RpcDirection_RpcDirection_MIN; + static constexpr RpcDirection RpcDirection_MAX = + SharingLog_RpcCallStatus_RpcDirection_RpcDirection_MAX; + static constexpr int RpcDirection_ARRAYSIZE = + SharingLog_RpcCallStatus_RpcDirection_RpcDirection_ARRAYSIZE; + template + static inline const std::string& RpcDirection_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function RpcDirection_Name."); + return SharingLog_RpcCallStatus_RpcDirection_Name(enum_t_value); + } + static inline bool RpcDirection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + RpcDirection* value) { + return SharingLog_RpcCallStatus_RpcDirection_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kRpcNameFieldNumber = 2, + kDirectionFieldNumber = 1, + kErrorCodeFieldNumber = 3, + kLatencyMillisFieldNumber = 4, + }; + // optional string rpc_name = 2; + bool has_rpc_name() const; + private: + bool _internal_has_rpc_name() const; + public: + void clear_rpc_name(); + const std::string& rpc_name() const; + template + void set_rpc_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_rpc_name(); + PROTOBUF_NODISCARD std::string* release_rpc_name(); + void set_allocated_rpc_name(std::string* rpc_name); + private: + const std::string& _internal_rpc_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_rpc_name(const std::string& value); + std::string* _internal_mutable_rpc_name(); + public: + + // optional .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.RpcDirection direction = 1; + bool has_direction() const; + private: + bool _internal_has_direction() const; + public: + void clear_direction(); + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection direction() const; + void set_direction(::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection value); + private: + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection _internal_direction() const; + void _internal_set_direction(::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection value); + public: + + // optional int32 error_code = 3; + bool has_error_code() const; + private: + bool _internal_has_error_code() const; + public: + void clear_error_code(); + int32_t error_code() const; + void set_error_code(int32_t value); + private: + int32_t _internal_error_code() const; + void _internal_set_error_code(int32_t value); + public: + + // optional int64 latency_millis = 4; + bool has_latency_millis() const; + private: + bool _internal_has_latency_millis() const; + public: + void clear_latency_millis(); + int64_t latency_millis() const; + void set_latency_millis(int64_t value); + private: + int64_t _internal_latency_millis() const; + void _internal_set_latency_millis(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus) + 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 rpc_name_; + int direction_; + int32_t error_code_; + int64_t latency_millis_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_StartQrCodeSession final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) */ { + public: + inline SharingLog_StartQrCodeSession() : SharingLog_StartQrCodeSession(nullptr) {} + ~SharingLog_StartQrCodeSession() override; + explicit constexpr SharingLog_StartQrCodeSession(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_StartQrCodeSession(const SharingLog_StartQrCodeSession& from); + SharingLog_StartQrCodeSession(SharingLog_StartQrCodeSession&& from) noexcept + : SharingLog_StartQrCodeSession() { + *this = ::std::move(from); + } + + inline SharingLog_StartQrCodeSession& operator=(const SharingLog_StartQrCodeSession& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_StartQrCodeSession& operator=(SharingLog_StartQrCodeSession&& 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 SharingLog_StartQrCodeSession& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_StartQrCodeSession* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_StartQrCodeSession_default_instance_); + } + static constexpr int kIndexInFileMessages = + 80; + + friend void swap(SharingLog_StartQrCodeSession& a, SharingLog_StartQrCodeSession& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_StartQrCodeSession* 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(SharingLog_StartQrCodeSession* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_StartQrCodeSession* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_StartQrCodeSession& from); + void MergeFrom(const SharingLog_StartQrCodeSession& 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(SharingLog_StartQrCodeSession* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession"; + } + protected: + explicit SharingLog_StartQrCodeSession(::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:nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession) + 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_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_QrCodeOpenedInWebClient final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) */ { + public: + inline SharingLog_QrCodeOpenedInWebClient() : SharingLog_QrCodeOpenedInWebClient(nullptr) {} + ~SharingLog_QrCodeOpenedInWebClient() override; + explicit constexpr SharingLog_QrCodeOpenedInWebClient(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_QrCodeOpenedInWebClient(const SharingLog_QrCodeOpenedInWebClient& from); + SharingLog_QrCodeOpenedInWebClient(SharingLog_QrCodeOpenedInWebClient&& from) noexcept + : SharingLog_QrCodeOpenedInWebClient() { + *this = ::std::move(from); + } + + inline SharingLog_QrCodeOpenedInWebClient& operator=(const SharingLog_QrCodeOpenedInWebClient& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_QrCodeOpenedInWebClient& operator=(SharingLog_QrCodeOpenedInWebClient&& 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 SharingLog_QrCodeOpenedInWebClient& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_QrCodeOpenedInWebClient* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_QrCodeOpenedInWebClient_default_instance_); + } + static constexpr int kIndexInFileMessages = + 81; + + friend void swap(SharingLog_QrCodeOpenedInWebClient& a, SharingLog_QrCodeOpenedInWebClient& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_QrCodeOpenedInWebClient* 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(SharingLog_QrCodeOpenedInWebClient* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_QrCodeOpenedInWebClient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_QrCodeOpenedInWebClient& from); + void MergeFrom(const SharingLog_QrCodeOpenedInWebClient& 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(SharingLog_QrCodeOpenedInWebClient* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient"; + } + protected: + explicit SharingLog_QrCodeOpenedInWebClient(::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 SharingLog_QrCodeOpenedInWebClient_ClientPlatform ClientPlatform; + static constexpr ClientPlatform UNKNOWN_CLIENT_PLATFORM = + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_UNKNOWN_CLIENT_PLATFORM; + static constexpr ClientPlatform GENERIC = + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_GENERIC; + static constexpr ClientPlatform ANDROID = + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_ANDROID; + static constexpr ClientPlatform IOS = + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_IOS; + static constexpr ClientPlatform CHROME_OS = + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_CHROME_OS; + static constexpr ClientPlatform WINDOWS = + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_WINDOWS; + static inline bool ClientPlatform_IsValid(int value) { + return SharingLog_QrCodeOpenedInWebClient_ClientPlatform_IsValid(value); + } + static constexpr ClientPlatform ClientPlatform_MIN = + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_ClientPlatform_MIN; + static constexpr ClientPlatform ClientPlatform_MAX = + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_ClientPlatform_MAX; + static constexpr int ClientPlatform_ARRAYSIZE = + SharingLog_QrCodeOpenedInWebClient_ClientPlatform_ClientPlatform_ARRAYSIZE; + template + static inline const std::string& ClientPlatform_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ClientPlatform_Name."); + return SharingLog_QrCodeOpenedInWebClient_ClientPlatform_Name(enum_t_value); + } + static inline bool ClientPlatform_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ClientPlatform* value) { + return SharingLog_QrCodeOpenedInWebClient_ClientPlatform_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kClientPlatformFieldNumber = 1, + kIsRetryFieldNumber = 2, + }; + // optional .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient.ClientPlatform client_platform = 1; + bool has_client_platform() const; + private: + bool _internal_has_client_platform() const; + public: + void clear_client_platform(); + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform client_platform() const; + void set_client_platform(::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform value); + private: + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform _internal_client_platform() const; + void _internal_set_client_platform(::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform value); + public: + + // optional bool is_retry = 2; + bool has_is_retry() const; + private: + bool _internal_has_is_retry() const; + public: + void clear_is_retry(); + bool is_retry() const; + void set_is_retry(bool value); + private: + bool _internal_is_retry() const; + void _internal_set_is_retry(bool value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient) + 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_; + int client_platform_; + bool is_retry_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_HatsJointEvent final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) */ { + public: + inline SharingLog_HatsJointEvent() : SharingLog_HatsJointEvent(nullptr) {} + ~SharingLog_HatsJointEvent() override; + explicit constexpr SharingLog_HatsJointEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_HatsJointEvent(const SharingLog_HatsJointEvent& from); + SharingLog_HatsJointEvent(SharingLog_HatsJointEvent&& from) noexcept + : SharingLog_HatsJointEvent() { + *this = ::std::move(from); + } + + inline SharingLog_HatsJointEvent& operator=(const SharingLog_HatsJointEvent& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_HatsJointEvent& operator=(SharingLog_HatsJointEvent&& 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 SharingLog_HatsJointEvent& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_HatsJointEvent* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_HatsJointEvent_default_instance_); + } + static constexpr int kIndexInFileMessages = + 82; + + friend void swap(SharingLog_HatsJointEvent& a, SharingLog_HatsJointEvent& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_HatsJointEvent* 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(SharingLog_HatsJointEvent* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_HatsJointEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_HatsJointEvent& from); + void MergeFrom(const SharingLog_HatsJointEvent& 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(SharingLog_HatsJointEvent* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.HatsJointEvent"; + } + protected: + explicit SharingLog_HatsJointEvent(::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 { + kHatsSessionIdFieldNumber = 2, + kFlowIdFieldNumber = 1, + }; + // optional string hats_session_id = 2; + bool has_hats_session_id() const; + private: + bool _internal_has_hats_session_id() const; + public: + void clear_hats_session_id(); + const std::string& hats_session_id() const; + template + void set_hats_session_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_hats_session_id(); + PROTOBUF_NODISCARD std::string* release_hats_session_id(); + void set_allocated_hats_session_id(std::string* hats_session_id); + private: + const std::string& _internal_hats_session_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_hats_session_id(const std::string& value); + std::string* _internal_mutable_hats_session_id(); + public: + + // optional int64 flow_id = 1; + bool has_flow_id() const; + private: + bool _internal_has_flow_id() const; + public: + void clear_flow_id(); + int64_t flow_id() const; + void set_flow_id(int64_t value); + private: + int64_t _internal_flow_id() const; + void _internal_set_flow_id(int64_t value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent) + 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 hats_session_id_; + int64_t flow_id_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_ReceivePreviews final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) */ { + public: + inline SharingLog_ReceivePreviews() : SharingLog_ReceivePreviews(nullptr) {} + ~SharingLog_ReceivePreviews() override; + explicit constexpr SharingLog_ReceivePreviews(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_ReceivePreviews(const SharingLog_ReceivePreviews& from); + SharingLog_ReceivePreviews(SharingLog_ReceivePreviews&& from) noexcept + : SharingLog_ReceivePreviews() { + *this = ::std::move(from); + } + + inline SharingLog_ReceivePreviews& operator=(const SharingLog_ReceivePreviews& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_ReceivePreviews& operator=(SharingLog_ReceivePreviews&& 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 SharingLog_ReceivePreviews& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_ReceivePreviews* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_ReceivePreviews_default_instance_); + } + static constexpr int kIndexInFileMessages = + 83; + + friend void swap(SharingLog_ReceivePreviews& a, SharingLog_ReceivePreviews& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_ReceivePreviews* 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(SharingLog_ReceivePreviews* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_ReceivePreviews* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_ReceivePreviews& from); + void MergeFrom(const SharingLog_ReceivePreviews& 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(SharingLog_ReceivePreviews* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.ReceivePreviews"; + } + protected: + explicit SharingLog_ReceivePreviews(::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 { + kNumPreviewsFieldNumber = 1, + }; + // optional int32 num_previews = 1; + bool has_num_previews() const; + private: + bool _internal_has_num_previews() const; + public: + void clear_num_previews(); + int32_t num_previews() const; + void set_num_previews(int32_t value); + private: + int32_t _internal_num_previews() const; + void _internal_set_num_previews(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews) + 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_; + int32_t num_previews_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_CloudCreateSharingRequest final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) */ { + public: + inline SharingLog_CloudCreateSharingRequest() : SharingLog_CloudCreateSharingRequest(nullptr) {} + ~SharingLog_CloudCreateSharingRequest() override; + explicit constexpr SharingLog_CloudCreateSharingRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_CloudCreateSharingRequest(const SharingLog_CloudCreateSharingRequest& from); + SharingLog_CloudCreateSharingRequest(SharingLog_CloudCreateSharingRequest&& from) noexcept + : SharingLog_CloudCreateSharingRequest() { + *this = ::std::move(from); + } + + inline SharingLog_CloudCreateSharingRequest& operator=(const SharingLog_CloudCreateSharingRequest& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_CloudCreateSharingRequest& operator=(SharingLog_CloudCreateSharingRequest&& 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 SharingLog_CloudCreateSharingRequest& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_CloudCreateSharingRequest* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_CloudCreateSharingRequest_default_instance_); + } + static constexpr int kIndexInFileMessages = + 84; + + friend void swap(SharingLog_CloudCreateSharingRequest& a, SharingLog_CloudCreateSharingRequest& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_CloudCreateSharingRequest* 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(SharingLog_CloudCreateSharingRequest* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_CloudCreateSharingRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_CloudCreateSharingRequest& from); + void MergeFrom(const SharingLog_CloudCreateSharingRequest& 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(SharingLog_CloudCreateSharingRequest* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest"; + } + protected: + explicit SharingLog_CloudCreateSharingRequest(::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 { + kAttachmentsInfoFieldNumber = 1, + kResultFieldNumber = 2, + }; + // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + bool has_attachments_info() const; + private: + bool _internal_has_attachments_info() const; + public: + void clear_attachments_info(); + const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& attachments_info() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* release_attachments_info(); + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* mutable_attachments_info(); + void set_allocated_attachments_info(::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info); + private: + const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& _internal_attachments_info() const; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* _internal_mutable_attachments_info(); + public: + void unsafe_arena_set_allocated_attachments_info( + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info); + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* unsafe_arena_release_attachments_info(); + + // optional .location.nearby.proto.sharing.CloudCreateSharingResult result = 2; + bool has_result() const; + private: + bool _internal_has_result() const; + public: + void clear_result(); + ::location::nearby::proto::sharing::CloudCreateSharingResult result() const; + void set_result(::location::nearby::proto::sharing::CloudCreateSharingResult value); + private: + ::location::nearby::proto::sharing::CloudCreateSharingResult _internal_result() const; + void _internal_set_result(::location::nearby::proto::sharing::CloudCreateSharingResult value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest) + 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_; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info_; + int result_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_CloudRegisterReceiver final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) */ { + public: + inline SharingLog_CloudRegisterReceiver() : SharingLog_CloudRegisterReceiver(nullptr) {} + ~SharingLog_CloudRegisterReceiver() override; + explicit constexpr SharingLog_CloudRegisterReceiver(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_CloudRegisterReceiver(const SharingLog_CloudRegisterReceiver& from); + SharingLog_CloudRegisterReceiver(SharingLog_CloudRegisterReceiver&& from) noexcept + : SharingLog_CloudRegisterReceiver() { + *this = ::std::move(from); + } + + inline SharingLog_CloudRegisterReceiver& operator=(const SharingLog_CloudRegisterReceiver& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_CloudRegisterReceiver& operator=(SharingLog_CloudRegisterReceiver&& 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 SharingLog_CloudRegisterReceiver& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_CloudRegisterReceiver* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_CloudRegisterReceiver_default_instance_); + } + static constexpr int kIndexInFileMessages = + 85; + + friend void swap(SharingLog_CloudRegisterReceiver& a, SharingLog_CloudRegisterReceiver& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_CloudRegisterReceiver* 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(SharingLog_CloudRegisterReceiver* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_CloudRegisterReceiver* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_CloudRegisterReceiver& from); + void MergeFrom(const SharingLog_CloudRegisterReceiver& 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(SharingLog_CloudRegisterReceiver* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver"; + } + protected: + explicit SharingLog_CloudRegisterReceiver(::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 { + kResultFieldNumber = 1, + }; + // optional .location.nearby.proto.sharing.CloudRegisterReceiverResult result = 1; + bool has_result() const; + private: + bool _internal_has_result() const; + public: + void clear_result(); + ::location::nearby::proto::sharing::CloudRegisterReceiverResult result() const; + void set_result(::location::nearby::proto::sharing::CloudRegisterReceiverResult value); + private: + ::location::nearby::proto::sharing::CloudRegisterReceiverResult _internal_result() const; + void _internal_set_result(::location::nearby::proto::sharing::CloudRegisterReceiverResult value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver) + 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_; + int result_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_CloudUploadStart final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) */ { + public: + inline SharingLog_CloudUploadStart() : SharingLog_CloudUploadStart(nullptr) {} + ~SharingLog_CloudUploadStart() override; + explicit constexpr SharingLog_CloudUploadStart(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_CloudUploadStart(const SharingLog_CloudUploadStart& from); + SharingLog_CloudUploadStart(SharingLog_CloudUploadStart&& from) noexcept + : SharingLog_CloudUploadStart() { + *this = ::std::move(from); + } + + inline SharingLog_CloudUploadStart& operator=(const SharingLog_CloudUploadStart& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_CloudUploadStart& operator=(SharingLog_CloudUploadStart&& 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 SharingLog_CloudUploadStart& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_CloudUploadStart* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_CloudUploadStart_default_instance_); + } + static constexpr int kIndexInFileMessages = + 86; + + friend void swap(SharingLog_CloudUploadStart& a, SharingLog_CloudUploadStart& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_CloudUploadStart* 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(SharingLog_CloudUploadStart* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_CloudUploadStart* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_CloudUploadStart& from); + void MergeFrom(const SharingLog_CloudUploadStart& 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(SharingLog_CloudUploadStart* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.CloudUploadStart"; + } + protected: + explicit SharingLog_CloudUploadStart(::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 { + kAttachmentsInfoFieldNumber = 1, + kActionTypeFieldNumber = 2, + }; + // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + bool has_attachments_info() const; + private: + bool _internal_has_attachments_info() const; + public: + void clear_attachments_info(); + const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& attachments_info() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* release_attachments_info(); + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* mutable_attachments_info(); + void set_allocated_attachments_info(::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info); + private: + const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& _internal_attachments_info() const; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* _internal_mutable_attachments_info(); + public: + void unsafe_arena_set_allocated_attachments_info( + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info); + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* unsafe_arena_release_attachments_info(); + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + bool has_action_type() const; + private: + bool _internal_has_action_type() const; + public: + void clear_action_type(); + ::location::nearby::proto::sharing::CloudActionType action_type() const; + void set_action_type(::location::nearby::proto::sharing::CloudActionType value); + private: + ::location::nearby::proto::sharing::CloudActionType _internal_action_type() const; + void _internal_set_action_type(::location::nearby::proto::sharing::CloudActionType value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart) + 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_; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info_; + int action_type_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_CloudUploadEnd final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) */ { + public: + inline SharingLog_CloudUploadEnd() : SharingLog_CloudUploadEnd(nullptr) {} + ~SharingLog_CloudUploadEnd() override; + explicit constexpr SharingLog_CloudUploadEnd(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_CloudUploadEnd(const SharingLog_CloudUploadEnd& from); + SharingLog_CloudUploadEnd(SharingLog_CloudUploadEnd&& from) noexcept + : SharingLog_CloudUploadEnd() { + *this = ::std::move(from); + } + + inline SharingLog_CloudUploadEnd& operator=(const SharingLog_CloudUploadEnd& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_CloudUploadEnd& operator=(SharingLog_CloudUploadEnd&& 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 SharingLog_CloudUploadEnd& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_CloudUploadEnd* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_CloudUploadEnd_default_instance_); + } + static constexpr int kIndexInFileMessages = + 87; + + friend void swap(SharingLog_CloudUploadEnd& a, SharingLog_CloudUploadEnd& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_CloudUploadEnd* 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(SharingLog_CloudUploadEnd* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_CloudUploadEnd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_CloudUploadEnd& from); + void MergeFrom(const SharingLog_CloudUploadEnd& 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(SharingLog_CloudUploadEnd* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd"; + } + protected: + explicit SharingLog_CloudUploadEnd(::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 { + kUploadInfosFieldNumber = 1, + kActionTypeFieldNumber = 2, + }; + // repeated .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo upload_infos = 1; + int upload_infos_size() const; + private: + int _internal_upload_infos_size() const; + public: + void clear_upload_infos(); + ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* mutable_upload_infos(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >* + mutable_upload_infos(); + private: + const ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo& _internal_upload_infos(int index) const; + ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* _internal_add_upload_infos(); + public: + const ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo& upload_infos(int index) const; + ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* add_upload_infos(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >& + upload_infos() const; + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + bool has_action_type() const; + private: + bool _internal_has_action_type() const; + public: + void clear_action_type(); + ::location::nearby::proto::sharing::CloudActionType action_type() const; + void set_action_type(::location::nearby::proto::sharing::CloudActionType value); + private: + ::location::nearby::proto::sharing::CloudActionType _internal_action_type() const; + void _internal_set_action_type(::location::nearby::proto::sharing::CloudActionType value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd) + 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::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo > upload_infos_; + int action_type_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_CloudDownloadStart final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) */ { + public: + inline SharingLog_CloudDownloadStart() : SharingLog_CloudDownloadStart(nullptr) {} + ~SharingLog_CloudDownloadStart() override; + explicit constexpr SharingLog_CloudDownloadStart(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_CloudDownloadStart(const SharingLog_CloudDownloadStart& from); + SharingLog_CloudDownloadStart(SharingLog_CloudDownloadStart&& from) noexcept + : SharingLog_CloudDownloadStart() { + *this = ::std::move(from); + } + + inline SharingLog_CloudDownloadStart& operator=(const SharingLog_CloudDownloadStart& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_CloudDownloadStart& operator=(SharingLog_CloudDownloadStart&& 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 SharingLog_CloudDownloadStart& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_CloudDownloadStart* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_CloudDownloadStart_default_instance_); + } + static constexpr int kIndexInFileMessages = + 88; + + friend void swap(SharingLog_CloudDownloadStart& a, SharingLog_CloudDownloadStart& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_CloudDownloadStart* 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(SharingLog_CloudDownloadStart* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_CloudDownloadStart* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_CloudDownloadStart& from); + void MergeFrom(const SharingLog_CloudDownloadStart& 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(SharingLog_CloudDownloadStart* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart"; + } + protected: + explicit SharingLog_CloudDownloadStart(::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 { + kAttachmentsInfoFieldNumber = 1, + kActionTypeFieldNumber = 2, + }; + // optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; + bool has_attachments_info() const; + private: + bool _internal_has_attachments_info() const; + public: + void clear_attachments_info(); + const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& attachments_info() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* release_attachments_info(); + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* mutable_attachments_info(); + void set_allocated_attachments_info(::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info); + private: + const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& _internal_attachments_info() const; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* _internal_mutable_attachments_info(); + public: + void unsafe_arena_set_allocated_attachments_info( + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info); + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* unsafe_arena_release_attachments_info(); + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + bool has_action_type() const; + private: + bool _internal_has_action_type() const; + public: + void clear_action_type(); + ::location::nearby::proto::sharing::CloudActionType action_type() const; + void set_action_type(::location::nearby::proto::sharing::CloudActionType value); + private: + ::location::nearby::proto::sharing::CloudActionType _internal_action_type() const; + void _internal_set_action_type(::location::nearby::proto::sharing::CloudActionType value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart) + 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_; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info_; + int action_type_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_CloudDownloadEnd final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) */ { + public: + inline SharingLog_CloudDownloadEnd() : SharingLog_CloudDownloadEnd(nullptr) {} + ~SharingLog_CloudDownloadEnd() override; + explicit constexpr SharingLog_CloudDownloadEnd(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_CloudDownloadEnd(const SharingLog_CloudDownloadEnd& from); + SharingLog_CloudDownloadEnd(SharingLog_CloudDownloadEnd&& from) noexcept + : SharingLog_CloudDownloadEnd() { + *this = ::std::move(from); + } + + inline SharingLog_CloudDownloadEnd& operator=(const SharingLog_CloudDownloadEnd& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_CloudDownloadEnd& operator=(SharingLog_CloudDownloadEnd&& 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 SharingLog_CloudDownloadEnd& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_CloudDownloadEnd* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_CloudDownloadEnd_default_instance_); + } + static constexpr int kIndexInFileMessages = + 89; + + friend void swap(SharingLog_CloudDownloadEnd& a, SharingLog_CloudDownloadEnd& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_CloudDownloadEnd* 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(SharingLog_CloudDownloadEnd* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_CloudDownloadEnd* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_CloudDownloadEnd& from); + void MergeFrom(const SharingLog_CloudDownloadEnd& 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(SharingLog_CloudDownloadEnd* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd"; + } + protected: + explicit SharingLog_CloudDownloadEnd(::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 { + kDownloadInfosFieldNumber = 1, + kActionTypeFieldNumber = 2, + }; + // repeated .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo download_infos = 1; + int download_infos_size() const; + private: + int _internal_download_infos_size() const; + public: + void clear_download_infos(); + ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* mutable_download_infos(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >* + mutable_download_infos(); + private: + const ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo& _internal_download_infos(int index) const; + ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* _internal_add_download_infos(); + public: + const ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo& download_infos(int index) const; + ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* add_download_infos(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >& + download_infos() const; + + // optional .location.nearby.proto.sharing.CloudActionType action_type = 2; + bool has_action_type() const; + private: + bool _internal_has_action_type() const; + public: + void clear_action_type(); + ::location::nearby::proto::sharing::CloudActionType action_type() const; + void set_action_type(::location::nearby::proto::sharing::CloudActionType value); + private: + ::location::nearby::proto::sharing::CloudActionType _internal_action_type() const; + void _internal_set_action_type(::location::nearby::proto::sharing::CloudActionType value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd) + 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::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo > download_infos_; + int action_type_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + +class SharingLog_CloudSharingRpcResult final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) */ { + public: + inline SharingLog_CloudSharingRpcResult() : SharingLog_CloudSharingRpcResult(nullptr) {} + ~SharingLog_CloudSharingRpcResult() override; + explicit constexpr SharingLog_CloudSharingRpcResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SharingLog_CloudSharingRpcResult(const SharingLog_CloudSharingRpcResult& from); + SharingLog_CloudSharingRpcResult(SharingLog_CloudSharingRpcResult&& from) noexcept + : SharingLog_CloudSharingRpcResult() { + *this = ::std::move(from); + } + + inline SharingLog_CloudSharingRpcResult& operator=(const SharingLog_CloudSharingRpcResult& from) { + CopyFrom(from); + return *this; + } + inline SharingLog_CloudSharingRpcResult& operator=(SharingLog_CloudSharingRpcResult&& 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 SharingLog_CloudSharingRpcResult& default_instance() { + return *internal_default_instance(); + } + static inline const SharingLog_CloudSharingRpcResult* internal_default_instance() { + return reinterpret_cast( + &_SharingLog_CloudSharingRpcResult_default_instance_); + } + static constexpr int kIndexInFileMessages = + 90; + + friend void swap(SharingLog_CloudSharingRpcResult& a, SharingLog_CloudSharingRpcResult& b) { + a.Swap(&b); + } + inline void Swap(SharingLog_CloudSharingRpcResult* 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(SharingLog_CloudSharingRpcResult* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SharingLog_CloudSharingRpcResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const SharingLog_CloudSharingRpcResult& from); + void MergeFrom(const SharingLog_CloudSharingRpcResult& 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(SharingLog_CloudSharingRpcResult* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult"; + } + protected: + explicit SharingLog_CloudSharingRpcResult(::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 { + kRpcNameFieldNumber = 1, + kCloudSharingIdFieldNumber = 4, + kLatencyMillisFieldNumber = 3, + kStatusCodeFieldNumber = 2, + }; + // optional string rpc_name = 1; + bool has_rpc_name() const; + private: + bool _internal_has_rpc_name() const; + public: + void clear_rpc_name(); + const std::string& rpc_name() const; + template + void set_rpc_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_rpc_name(); + PROTOBUF_NODISCARD std::string* release_rpc_name(); + void set_allocated_rpc_name(std::string* rpc_name); + private: + const std::string& _internal_rpc_name() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_rpc_name(const std::string& value); + std::string* _internal_mutable_rpc_name(); + public: + + // optional string cloud_sharing_id = 4; + bool has_cloud_sharing_id() const; + private: + bool _internal_has_cloud_sharing_id() const; + public: + void clear_cloud_sharing_id(); + const std::string& cloud_sharing_id() const; + template + void set_cloud_sharing_id(ArgT0&& arg0, ArgT... args); + std::string* mutable_cloud_sharing_id(); + PROTOBUF_NODISCARD std::string* release_cloud_sharing_id(); + void set_allocated_cloud_sharing_id(std::string* cloud_sharing_id); + private: + const std::string& _internal_cloud_sharing_id() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_cloud_sharing_id(const std::string& value); + std::string* _internal_mutable_cloud_sharing_id(); + public: + + // optional int64 latency_millis = 3; + bool has_latency_millis() const; + private: + bool _internal_has_latency_millis() const; + public: + void clear_latency_millis(); + int64_t latency_millis() const; + void set_latency_millis(int64_t value); + private: + int64_t _internal_latency_millis() const; + void _internal_set_latency_millis(int64_t value); + public: + + // optional int32 status_code = 2; + bool has_status_code() const; + private: + bool _internal_has_status_code() const; + public: + void clear_status_code(); + int32_t status_code() const; + void set_status_code(int32_t value); + private: + int32_t _internal_status_code() const; + void _internal_set_status_code(int32_t value); + public: + + // @@protoc_insertion_point(class_scope:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult) + 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 rpc_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cloud_sharing_id_; + int64_t latency_millis_; + int32_t status_code_; + friend struct ::TableStruct_sharing_2fproto_2fanalytics_2fnearby_5fsharing_5flog_2eproto; +}; +// ------------------------------------------------------------------- + class SharingLog final : public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:nearby.sharing.analytics.proto.SharingLog) */ { public: @@ -13105,7 +16380,7 @@ class SharingLog final : &_SharingLog_default_instance_); } static constexpr int kIndexInFileMessages = - 76; + 91; friend void swap(SharingLog& a, SharingLog& b) { a.Swap(&b); @@ -13241,10 +16516,25 @@ class SharingLog final : typedef SharingLog_WifiCredentialsAttachment WifiCredentialsAttachment; typedef SharingLog_AppAttachment AppAttachment; typedef SharingLog_StreamAttachment StreamAttachment; + typedef SharingLog_CloudAttachmentInfo CloudAttachmentInfo; typedef SharingLog_AppCrash AppCrash; typedef SharingLog_SetupWizard SetupWizard; typedef SharingLog_SendDesktopNotification SendDesktopNotification; typedef SharingLog_SendDesktopTransferEvent SendDesktopTransferEvent; + typedef SharingLog_ShowWaitingForAccept ShowWaitingForAccept; + typedef SharingLog_HighQualityMediumSetup HighQualityMediumSetup; + typedef SharingLog_RpcCallStatus RpcCallStatus; + typedef SharingLog_StartQrCodeSession StartQrCodeSession; + typedef SharingLog_QrCodeOpenedInWebClient QrCodeOpenedInWebClient; + typedef SharingLog_HatsJointEvent HatsJointEvent; + typedef SharingLog_ReceivePreviews ReceivePreviews; + typedef SharingLog_CloudCreateSharingRequest CloudCreateSharingRequest; + typedef SharingLog_CloudRegisterReceiver CloudRegisterReceiver; + typedef SharingLog_CloudUploadStart CloudUploadStart; + typedef SharingLog_CloudUploadEnd CloudUploadEnd; + typedef SharingLog_CloudDownloadStart CloudDownloadStart; + typedef SharingLog_CloudDownloadEnd CloudDownloadEnd; + typedef SharingLog_CloudSharingRpcResult CloudSharingRpcResult; // accessors ------------------------------------------------------- @@ -13320,6 +16610,20 @@ class SharingLog final : kSetAccountFieldNumber = 73, kDecryptCertificateFailureFieldNumber = 74, kShowAllowPermissionAutoAccessFieldNumber = 75, + kShowWaitingForAcceptFieldNumber = 76, + kHighQualityMediumSetupFieldNumber = 77, + kRpcCallStatusFieldNumber = 78, + kStartQrCodeSessionFieldNumber = 79, + kQrCodeOpenedInWebClientFieldNumber = 80, + kHatsJointEventFieldNumber = 81, + kReceivePreviewsFieldNumber = 82, + kCloudCreateSharingRequestFieldNumber = 83, + kCloudRegisterReceiverFieldNumber = 84, + kCloudUploadStartFieldNumber = 85, + kCloudUploadEndFieldNumber = 86, + kCloudDownloadStartFieldNumber = 87, + kCloudDownloadEndFieldNumber = 88, + kCloudSharingRpcResultFieldNumber = 89, kEventTypeFieldNumber = 1, kLogSourceFieldNumber = 27, kEventCategoryFieldNumber = 33, @@ -14602,6 +17906,258 @@ class SharingLog final : ::nearby::sharing::analytics::proto::SharingLog_ShowAllowPermissionAutoAccess* show_allow_permission_auto_access); ::nearby::sharing::analytics::proto::SharingLog_ShowAllowPermissionAutoAccess* unsafe_arena_release_show_allow_permission_auto_access(); + // optional .nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept show_waiting_for_accept = 76; + bool has_show_waiting_for_accept() const; + private: + bool _internal_has_show_waiting_for_accept() const; + public: + void clear_show_waiting_for_accept(); + const ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept& show_waiting_for_accept() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* release_show_waiting_for_accept(); + ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* mutable_show_waiting_for_accept(); + void set_allocated_show_waiting_for_accept(::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* show_waiting_for_accept); + private: + const ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept& _internal_show_waiting_for_accept() const; + ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* _internal_mutable_show_waiting_for_accept(); + public: + void unsafe_arena_set_allocated_show_waiting_for_accept( + ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* show_waiting_for_accept); + ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* unsafe_arena_release_show_waiting_for_accept(); + + // optional .nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup high_quality_medium_setup = 77; + bool has_high_quality_medium_setup() const; + private: + bool _internal_has_high_quality_medium_setup() const; + public: + void clear_high_quality_medium_setup(); + const ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup& high_quality_medium_setup() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* release_high_quality_medium_setup(); + ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* mutable_high_quality_medium_setup(); + void set_allocated_high_quality_medium_setup(::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* high_quality_medium_setup); + private: + const ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup& _internal_high_quality_medium_setup() const; + ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* _internal_mutable_high_quality_medium_setup(); + public: + void unsafe_arena_set_allocated_high_quality_medium_setup( + ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* high_quality_medium_setup); + ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* unsafe_arena_release_high_quality_medium_setup(); + + // optional .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus rpc_call_status = 78; + bool has_rpc_call_status() const; + private: + bool _internal_has_rpc_call_status() const; + public: + void clear_rpc_call_status(); + const ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus& rpc_call_status() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* release_rpc_call_status(); + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* mutable_rpc_call_status(); + void set_allocated_rpc_call_status(::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* rpc_call_status); + private: + const ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus& _internal_rpc_call_status() const; + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* _internal_mutable_rpc_call_status(); + public: + void unsafe_arena_set_allocated_rpc_call_status( + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* rpc_call_status); + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* unsafe_arena_release_rpc_call_status(); + + // optional .nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession start_qr_code_session = 79; + bool has_start_qr_code_session() const; + private: + bool _internal_has_start_qr_code_session() const; + public: + void clear_start_qr_code_session(); + const ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession& start_qr_code_session() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* release_start_qr_code_session(); + ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* mutable_start_qr_code_session(); + void set_allocated_start_qr_code_session(::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* start_qr_code_session); + private: + const ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession& _internal_start_qr_code_session() const; + ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* _internal_mutable_start_qr_code_session(); + public: + void unsafe_arena_set_allocated_start_qr_code_session( + ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* start_qr_code_session); + ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* unsafe_arena_release_start_qr_code_session(); + + // optional .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient qr_code_opened_in_web_client = 80; + bool has_qr_code_opened_in_web_client() const; + private: + bool _internal_has_qr_code_opened_in_web_client() const; + public: + void clear_qr_code_opened_in_web_client(); + const ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient& qr_code_opened_in_web_client() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* release_qr_code_opened_in_web_client(); + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* mutable_qr_code_opened_in_web_client(); + void set_allocated_qr_code_opened_in_web_client(::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* qr_code_opened_in_web_client); + private: + const ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient& _internal_qr_code_opened_in_web_client() const; + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* _internal_mutable_qr_code_opened_in_web_client(); + public: + void unsafe_arena_set_allocated_qr_code_opened_in_web_client( + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* qr_code_opened_in_web_client); + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* unsafe_arena_release_qr_code_opened_in_web_client(); + + // optional .nearby.sharing.analytics.proto.SharingLog.HatsJointEvent hats_joint_event = 81; + bool has_hats_joint_event() const; + private: + bool _internal_has_hats_joint_event() const; + public: + void clear_hats_joint_event(); + const ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent& hats_joint_event() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* release_hats_joint_event(); + ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* mutable_hats_joint_event(); + void set_allocated_hats_joint_event(::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* hats_joint_event); + private: + const ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent& _internal_hats_joint_event() const; + ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* _internal_mutable_hats_joint_event(); + public: + void unsafe_arena_set_allocated_hats_joint_event( + ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* hats_joint_event); + ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* unsafe_arena_release_hats_joint_event(); + + // optional .nearby.sharing.analytics.proto.SharingLog.ReceivePreviews receive_previews = 82; + bool has_receive_previews() const; + private: + bool _internal_has_receive_previews() const; + public: + void clear_receive_previews(); + const ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews& receive_previews() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* release_receive_previews(); + ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* mutable_receive_previews(); + void set_allocated_receive_previews(::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* receive_previews); + private: + const ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews& _internal_receive_previews() const; + ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* _internal_mutable_receive_previews(); + public: + void unsafe_arena_set_allocated_receive_previews( + ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* receive_previews); + ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* unsafe_arena_release_receive_previews(); + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest cloud_create_sharing_request = 83; + bool has_cloud_create_sharing_request() const; + private: + bool _internal_has_cloud_create_sharing_request() const; + public: + void clear_cloud_create_sharing_request(); + const ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest& cloud_create_sharing_request() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* release_cloud_create_sharing_request(); + ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* mutable_cloud_create_sharing_request(); + void set_allocated_cloud_create_sharing_request(::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* cloud_create_sharing_request); + private: + const ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest& _internal_cloud_create_sharing_request() const; + ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* _internal_mutable_cloud_create_sharing_request(); + public: + void unsafe_arena_set_allocated_cloud_create_sharing_request( + ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* cloud_create_sharing_request); + ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* unsafe_arena_release_cloud_create_sharing_request(); + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver cloud_register_receiver = 84; + bool has_cloud_register_receiver() const; + private: + bool _internal_has_cloud_register_receiver() const; + public: + void clear_cloud_register_receiver(); + const ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver& cloud_register_receiver() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* release_cloud_register_receiver(); + ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* mutable_cloud_register_receiver(); + void set_allocated_cloud_register_receiver(::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* cloud_register_receiver); + private: + const ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver& _internal_cloud_register_receiver() const; + ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* _internal_mutable_cloud_register_receiver(); + public: + void unsafe_arena_set_allocated_cloud_register_receiver( + ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* cloud_register_receiver); + ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* unsafe_arena_release_cloud_register_receiver(); + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadStart cloud_upload_start = 85; + bool has_cloud_upload_start() const; + private: + bool _internal_has_cloud_upload_start() const; + public: + void clear_cloud_upload_start(); + const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart& cloud_upload_start() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* release_cloud_upload_start(); + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* mutable_cloud_upload_start(); + void set_allocated_cloud_upload_start(::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* cloud_upload_start); + private: + const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart& _internal_cloud_upload_start() const; + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* _internal_mutable_cloud_upload_start(); + public: + void unsafe_arena_set_allocated_cloud_upload_start( + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* cloud_upload_start); + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* unsafe_arena_release_cloud_upload_start(); + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd cloud_upload_end = 86; + bool has_cloud_upload_end() const; + private: + bool _internal_has_cloud_upload_end() const; + public: + void clear_cloud_upload_end(); + const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd& cloud_upload_end() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* release_cloud_upload_end(); + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* mutable_cloud_upload_end(); + void set_allocated_cloud_upload_end(::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* cloud_upload_end); + private: + const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd& _internal_cloud_upload_end() const; + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* _internal_mutable_cloud_upload_end(); + public: + void unsafe_arena_set_allocated_cloud_upload_end( + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* cloud_upload_end); + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* unsafe_arena_release_cloud_upload_end(); + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart cloud_download_start = 87; + bool has_cloud_download_start() const; + private: + bool _internal_has_cloud_download_start() const; + public: + void clear_cloud_download_start(); + const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart& cloud_download_start() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* release_cloud_download_start(); + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* mutable_cloud_download_start(); + void set_allocated_cloud_download_start(::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* cloud_download_start); + private: + const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart& _internal_cloud_download_start() const; + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* _internal_mutable_cloud_download_start(); + public: + void unsafe_arena_set_allocated_cloud_download_start( + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* cloud_download_start); + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* unsafe_arena_release_cloud_download_start(); + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd cloud_download_end = 88; + bool has_cloud_download_end() const; + private: + bool _internal_has_cloud_download_end() const; + public: + void clear_cloud_download_end(); + const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd& cloud_download_end() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* release_cloud_download_end(); + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* mutable_cloud_download_end(); + void set_allocated_cloud_download_end(::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* cloud_download_end); + private: + const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd& _internal_cloud_download_end() const; + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* _internal_mutable_cloud_download_end(); + public: + void unsafe_arena_set_allocated_cloud_download_end( + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* cloud_download_end); + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* unsafe_arena_release_cloud_download_end(); + + // optional .nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult cloud_sharing_rpc_result = 89; + bool has_cloud_sharing_rpc_result() const; + private: + bool _internal_has_cloud_sharing_rpc_result() const; + public: + void clear_cloud_sharing_rpc_result(); + const ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult& cloud_sharing_rpc_result() const; + PROTOBUF_NODISCARD ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* release_cloud_sharing_rpc_result(); + ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* mutable_cloud_sharing_rpc_result(); + void set_allocated_cloud_sharing_rpc_result(::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* cloud_sharing_rpc_result); + private: + const ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult& _internal_cloud_sharing_rpc_result() const; + ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* _internal_mutable_cloud_sharing_rpc_result(); + public: + void unsafe_arena_set_allocated_cloud_sharing_rpc_result( + ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* cloud_sharing_rpc_result); + ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* unsafe_arena_release_cloud_sharing_rpc_result(); + // optional .location.nearby.proto.sharing.EventType event_type = 1; bool has_event_type() const; private: @@ -14721,6 +18277,20 @@ class SharingLog final : ::nearby::sharing::analytics::proto::SharingLog_SetAccount* set_account_; ::nearby::sharing::analytics::proto::SharingLog_DecryptCertificateFailure* decrypt_certificate_failure_; ::nearby::sharing::analytics::proto::SharingLog_ShowAllowPermissionAutoAccess* show_allow_permission_auto_access_; + ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* show_waiting_for_accept_; + ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* high_quality_medium_setup_; + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* rpc_call_status_; + ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* start_qr_code_session_; + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* qr_code_opened_in_web_client_; + ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* hats_joint_event_; + ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* receive_previews_; + ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* cloud_create_sharing_request_; + ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* cloud_register_receiver_; + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* cloud_upload_start_; + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* cloud_upload_end_; + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* cloud_download_start_; + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* cloud_download_end_; + ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* cloud_sharing_rpc_result_; int event_type_; int log_source_; int event_category_; @@ -15146,6 +18716,148 @@ inline void SharingLog_DeviceSettings::set_is_wifi_enabled(bool value) { // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.is_wifi_enabled) } +// optional int32 first_successful_transfer_date = 8; +inline bool SharingLog_DeviceSettings::_internal_has_first_successful_transfer_date() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool SharingLog_DeviceSettings::has_first_successful_transfer_date() const { + return _internal_has_first_successful_transfer_date(); +} +inline void SharingLog_DeviceSettings::clear_first_successful_transfer_date() { + first_successful_transfer_date_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline int32_t SharingLog_DeviceSettings::_internal_first_successful_transfer_date() const { + return first_successful_transfer_date_; +} +inline int32_t SharingLog_DeviceSettings::first_successful_transfer_date() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.first_successful_transfer_date) + return _internal_first_successful_transfer_date(); +} +inline void SharingLog_DeviceSettings::_internal_set_first_successful_transfer_date(int32_t value) { + _has_bits_[0] |= 0x00000080u; + first_successful_transfer_date_ = value; +} +inline void SharingLog_DeviceSettings::set_first_successful_transfer_date(int32_t value) { + _internal_set_first_successful_transfer_date(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.first_successful_transfer_date) +} + +// optional int32 previous_successful_transfer_date = 9; +inline bool SharingLog_DeviceSettings::_internal_has_previous_successful_transfer_date() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool SharingLog_DeviceSettings::has_previous_successful_transfer_date() const { + return _internal_has_previous_successful_transfer_date(); +} +inline void SharingLog_DeviceSettings::clear_previous_successful_transfer_date() { + previous_successful_transfer_date_ = 0; + _has_bits_[0] &= ~0x00000100u; +} +inline int32_t SharingLog_DeviceSettings::_internal_previous_successful_transfer_date() const { + return previous_successful_transfer_date_; +} +inline int32_t SharingLog_DeviceSettings::previous_successful_transfer_date() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.previous_successful_transfer_date) + return _internal_previous_successful_transfer_date(); +} +inline void SharingLog_DeviceSettings::_internal_set_previous_successful_transfer_date(int32_t value) { + _has_bits_[0] |= 0x00000100u; + previous_successful_transfer_date_ = value; +} +inline void SharingLog_DeviceSettings::set_previous_successful_transfer_date(int32_t value) { + _internal_set_previous_successful_transfer_date(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.previous_successful_transfer_date) +} + +// optional int32 lifetime_transfer_count = 10; +inline bool SharingLog_DeviceSettings::_internal_has_lifetime_transfer_count() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool SharingLog_DeviceSettings::has_lifetime_transfer_count() const { + return _internal_has_lifetime_transfer_count(); +} +inline void SharingLog_DeviceSettings::clear_lifetime_transfer_count() { + lifetime_transfer_count_ = 0; + _has_bits_[0] &= ~0x00000200u; +} +inline int32_t SharingLog_DeviceSettings::_internal_lifetime_transfer_count() const { + return lifetime_transfer_count_; +} +inline int32_t SharingLog_DeviceSettings::lifetime_transfer_count() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.lifetime_transfer_count) + return _internal_lifetime_transfer_count(); +} +inline void SharingLog_DeviceSettings::_internal_set_lifetime_transfer_count(int32_t value) { + _has_bits_[0] |= 0x00000200u; + lifetime_transfer_count_ = value; +} +inline void SharingLog_DeviceSettings::set_lifetime_transfer_count(int32_t value) { + _internal_set_lifetime_transfer_count(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.lifetime_transfer_count) +} + +// optional .location.nearby.proto.sharing.ContactAccess contact_access = 11; +inline bool SharingLog_DeviceSettings::_internal_has_contact_access() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool SharingLog_DeviceSettings::has_contact_access() const { + return _internal_has_contact_access(); +} +inline void SharingLog_DeviceSettings::clear_contact_access() { + contact_access_ = 0; + _has_bits_[0] &= ~0x00000400u; +} +inline ::location::nearby::proto::sharing::ContactAccess SharingLog_DeviceSettings::_internal_contact_access() const { + return static_cast< ::location::nearby::proto::sharing::ContactAccess >(contact_access_); +} +inline ::location::nearby::proto::sharing::ContactAccess SharingLog_DeviceSettings::contact_access() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.contact_access) + return _internal_contact_access(); +} +inline void SharingLog_DeviceSettings::_internal_set_contact_access(::location::nearby::proto::sharing::ContactAccess value) { + assert(::location::nearby::proto::sharing::ContactAccess_IsValid(value)); + _has_bits_[0] |= 0x00000400u; + contact_access_ = value; +} +inline void SharingLog_DeviceSettings::set_contact_access(::location::nearby::proto::sharing::ContactAccess value) { + _internal_set_contact_access(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.contact_access) +} + +// optional .location.nearby.proto.sharing.IdentityVerification identity_verification = 12; +inline bool SharingLog_DeviceSettings::_internal_has_identity_verification() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool SharingLog_DeviceSettings::has_identity_verification() const { + return _internal_has_identity_verification(); +} +inline void SharingLog_DeviceSettings::clear_identity_verification() { + identity_verification_ = 0; + _has_bits_[0] &= ~0x00000800u; +} +inline ::location::nearby::proto::sharing::IdentityVerification SharingLog_DeviceSettings::_internal_identity_verification() const { + return static_cast< ::location::nearby::proto::sharing::IdentityVerification >(identity_verification_); +} +inline ::location::nearby::proto::sharing::IdentityVerification SharingLog_DeviceSettings::identity_verification() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.identity_verification) + return _internal_identity_verification(); +} +inline void SharingLog_DeviceSettings::_internal_set_identity_verification(::location::nearby::proto::sharing::IdentityVerification value) { + assert(::location::nearby::proto::sharing::IdentityVerification_IsValid(value)); + _has_bits_[0] |= 0x00000800u; + identity_verification_ = value; +} +inline void SharingLog_DeviceSettings::set_identity_verification(::location::nearby::proto::sharing::IdentityVerification value) { + _internal_set_identity_verification(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.DeviceSettings.identity_verification) +} + // ------------------------------------------------------------------- // SharingLog_PreferencesUsage @@ -15276,7 +18988,7 @@ inline void SharingLog_PreferencesUsage::set_next_sub_action(::location::nearby: // optional .location.nearby.proto.sharing.EstablishConnectionStatus status = 1; inline bool SharingLog_EstablishConnection::_internal_has_status() const { - bool value = (_has_bits_[0] & 0x00000008u) != 0; + bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool SharingLog_EstablishConnection::has_status() const { @@ -15284,7 +18996,7 @@ inline bool SharingLog_EstablishConnection::has_status() const { } inline void SharingLog_EstablishConnection::clear_status() { status_ = 0; - _has_bits_[0] &= ~0x00000008u; + _has_bits_[0] &= ~0x00000010u; } inline ::location::nearby::proto::sharing::EstablishConnectionStatus SharingLog_EstablishConnection::_internal_status() const { return static_cast< ::location::nearby::proto::sharing::EstablishConnectionStatus >(status_); @@ -15295,7 +19007,7 @@ inline ::location::nearby::proto::sharing::EstablishConnectionStatus SharingLog_ } inline void SharingLog_EstablishConnection::_internal_set_status(::location::nearby::proto::sharing::EstablishConnectionStatus value) { assert(::location::nearby::proto::sharing::EstablishConnectionStatus_IsValid(value)); - _has_bits_[0] |= 0x00000008u; + _has_bits_[0] |= 0x00000010u; status_ = value; } inline void SharingLog_EstablishConnection::set_status(::location::nearby::proto::sharing::EstablishConnectionStatus value) { @@ -15305,7 +19017,7 @@ inline void SharingLog_EstablishConnection::set_status(::location::nearby::proto // optional int64 session_id = 2; inline bool SharingLog_EstablishConnection::_internal_has_session_id() const { - bool value = (_has_bits_[0] & 0x00000004u) != 0; + bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool SharingLog_EstablishConnection::has_session_id() const { @@ -15313,7 +19025,7 @@ inline bool SharingLog_EstablishConnection::has_session_id() const { } inline void SharingLog_EstablishConnection::clear_session_id() { session_id_ = int64_t{0}; - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000008u; } inline int64_t SharingLog_EstablishConnection::_internal_session_id() const { return session_id_; @@ -15323,7 +19035,7 @@ inline int64_t SharingLog_EstablishConnection::session_id() const { return _internal_session_id(); } inline void SharingLog_EstablishConnection::_internal_set_session_id(int64_t value) { - _has_bits_[0] |= 0x00000004u; + _has_bits_[0] |= 0x00000008u; session_id_ = value; } inline void SharingLog_EstablishConnection::set_session_id(int64_t value) { @@ -15333,7 +19045,7 @@ inline void SharingLog_EstablishConnection::set_session_id(int64_t value) { // optional int32 transfer_position = 3; inline bool SharingLog_EstablishConnection::_internal_has_transfer_position() const { - bool value = (_has_bits_[0] & 0x00000010u) != 0; + bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool SharingLog_EstablishConnection::has_transfer_position() const { @@ -15341,7 +19053,7 @@ inline bool SharingLog_EstablishConnection::has_transfer_position() const { } inline void SharingLog_EstablishConnection::clear_transfer_position() { transfer_position_ = 0; - _has_bits_[0] &= ~0x00000010u; + _has_bits_[0] &= ~0x00000020u; } inline int32_t SharingLog_EstablishConnection::_internal_transfer_position() const { return transfer_position_; @@ -15351,7 +19063,7 @@ inline int32_t SharingLog_EstablishConnection::transfer_position() const { return _internal_transfer_position(); } inline void SharingLog_EstablishConnection::_internal_set_transfer_position(int32_t value) { - _has_bits_[0] |= 0x00000010u; + _has_bits_[0] |= 0x00000020u; transfer_position_ = value; } inline void SharingLog_EstablishConnection::set_transfer_position(int32_t value) { @@ -15361,7 +19073,7 @@ inline void SharingLog_EstablishConnection::set_transfer_position(int32_t value) // optional int32 concurrent_connections = 4; inline bool SharingLog_EstablishConnection::_internal_has_concurrent_connections() const { - bool value = (_has_bits_[0] & 0x00000040u) != 0; + bool value = (_has_bits_[0] & 0x00000080u) != 0; return value; } inline bool SharingLog_EstablishConnection::has_concurrent_connections() const { @@ -15369,7 +19081,7 @@ inline bool SharingLog_EstablishConnection::has_concurrent_connections() const { } inline void SharingLog_EstablishConnection::clear_concurrent_connections() { concurrent_connections_ = 0; - _has_bits_[0] &= ~0x00000040u; + _has_bits_[0] &= ~0x00000080u; } inline int32_t SharingLog_EstablishConnection::_internal_concurrent_connections() const { return concurrent_connections_; @@ -15379,7 +19091,7 @@ inline int32_t SharingLog_EstablishConnection::concurrent_connections() const { return _internal_concurrent_connections(); } inline void SharingLog_EstablishConnection::_internal_set_concurrent_connections(int32_t value) { - _has_bits_[0] |= 0x00000040u; + _has_bits_[0] |= 0x00000080u; concurrent_connections_ = value; } inline void SharingLog_EstablishConnection::set_concurrent_connections(int32_t value) { @@ -15389,7 +19101,7 @@ inline void SharingLog_EstablishConnection::set_concurrent_connections(int32_t v // optional int64 duration_millis = 5; inline bool SharingLog_EstablishConnection::_internal_has_duration_millis() const { - bool value = (_has_bits_[0] & 0x00000020u) != 0; + bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool SharingLog_EstablishConnection::has_duration_millis() const { @@ -15397,7 +19109,7 @@ inline bool SharingLog_EstablishConnection::has_duration_millis() const { } inline void SharingLog_EstablishConnection::clear_duration_millis() { duration_millis_ = int64_t{0}; - _has_bits_[0] &= ~0x00000020u; + _has_bits_[0] &= ~0x00000040u; } inline int64_t SharingLog_EstablishConnection::_internal_duration_millis() const { return duration_millis_; @@ -15407,7 +19119,7 @@ inline int64_t SharingLog_EstablishConnection::duration_millis() const { return _internal_duration_millis(); } inline void SharingLog_EstablishConnection::_internal_set_duration_millis(int64_t value) { - _has_bits_[0] |= 0x00000020u; + _has_bits_[0] |= 0x00000040u; duration_millis_ = value; } inline void SharingLog_EstablishConnection::set_duration_millis(int64_t value) { @@ -15574,9 +19286,9 @@ inline void SharingLog_EstablishConnection::set_allocated_referrer_name(std::str // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.EstablishConnection.referrer_name) } -// optional bool qr_code_flow = 8; +// optional bool qr_code_flow = 8 [deprecated = true]; inline bool SharingLog_EstablishConnection::_internal_has_qr_code_flow() const { - bool value = (_has_bits_[0] & 0x00000080u) != 0; + bool value = (_has_bits_[0] & 0x00000100u) != 0; return value; } inline bool SharingLog_EstablishConnection::has_qr_code_flow() const { @@ -15584,7 +19296,7 @@ inline bool SharingLog_EstablishConnection::has_qr_code_flow() const { } inline void SharingLog_EstablishConnection::clear_qr_code_flow() { qr_code_flow_ = false; - _has_bits_[0] &= ~0x00000080u; + _has_bits_[0] &= ~0x00000100u; } inline bool SharingLog_EstablishConnection::_internal_qr_code_flow() const { return qr_code_flow_; @@ -15594,7 +19306,7 @@ inline bool SharingLog_EstablishConnection::qr_code_flow() const { return _internal_qr_code_flow(); } inline void SharingLog_EstablishConnection::_internal_set_qr_code_flow(bool value) { - _has_bits_[0] |= 0x00000080u; + _has_bits_[0] |= 0x00000100u; qr_code_flow_ = value; } inline void SharingLog_EstablishConnection::set_qr_code_flow(bool value) { @@ -15604,7 +19316,7 @@ inline void SharingLog_EstablishConnection::set_qr_code_flow(bool value) { // optional bool is_incoming_connection = 9; inline bool SharingLog_EstablishConnection::_internal_has_is_incoming_connection() const { - bool value = (_has_bits_[0] & 0x00000100u) != 0; + bool value = (_has_bits_[0] & 0x00000200u) != 0; return value; } inline bool SharingLog_EstablishConnection::has_is_incoming_connection() const { @@ -15612,7 +19324,7 @@ inline bool SharingLog_EstablishConnection::has_is_incoming_connection() const { } inline void SharingLog_EstablishConnection::clear_is_incoming_connection() { is_incoming_connection_ = false; - _has_bits_[0] &= ~0x00000100u; + _has_bits_[0] &= ~0x00000200u; } inline bool SharingLog_EstablishConnection::_internal_is_incoming_connection() const { return is_incoming_connection_; @@ -15622,7 +19334,7 @@ inline bool SharingLog_EstablishConnection::is_incoming_connection() const { return _internal_is_incoming_connection(); } inline void SharingLog_EstablishConnection::_internal_set_is_incoming_connection(bool value) { - _has_bits_[0] |= 0x00000100u; + _has_bits_[0] |= 0x00000200u; is_incoming_connection_ = value; } inline void SharingLog_EstablishConnection::set_is_incoming_connection(bool value) { @@ -15630,6 +19342,94 @@ inline void SharingLog_EstablishConnection::set_is_incoming_connection(bool valu // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.EstablishConnection.is_incoming_connection) } +// optional .google.protobuf.Duration qr_code_receiver_connect_latency = 10; +inline bool SharingLog_EstablishConnection::_internal_has_qr_code_receiver_connect_latency() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || qr_code_receiver_connect_latency_ != nullptr); + return value; +} +inline bool SharingLog_EstablishConnection::has_qr_code_receiver_connect_latency() const { + return _internal_has_qr_code_receiver_connect_latency(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Duration& SharingLog_EstablishConnection::_internal_qr_code_receiver_connect_latency() const { + const ::PROTOBUF_NAMESPACE_ID::Duration* p = qr_code_receiver_connect_latency_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Duration_default_instance_); +} +inline const ::PROTOBUF_NAMESPACE_ID::Duration& SharingLog_EstablishConnection::qr_code_receiver_connect_latency() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.EstablishConnection.qr_code_receiver_connect_latency) + return _internal_qr_code_receiver_connect_latency(); +} +inline void SharingLog_EstablishConnection::unsafe_arena_set_allocated_qr_code_receiver_connect_latency( + ::PROTOBUF_NAMESPACE_ID::Duration* qr_code_receiver_connect_latency) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qr_code_receiver_connect_latency_); + } + qr_code_receiver_connect_latency_ = qr_code_receiver_connect_latency; + if (qr_code_receiver_connect_latency) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.EstablishConnection.qr_code_receiver_connect_latency) +} +inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_EstablishConnection::release_qr_code_receiver_connect_latency() { + _has_bits_[0] &= ~0x00000004u; + ::PROTOBUF_NAMESPACE_ID::Duration* temp = qr_code_receiver_connect_latency_; + qr_code_receiver_connect_latency_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_EstablishConnection::unsafe_arena_release_qr_code_receiver_connect_latency() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.EstablishConnection.qr_code_receiver_connect_latency) + _has_bits_[0] &= ~0x00000004u; + ::PROTOBUF_NAMESPACE_ID::Duration* temp = qr_code_receiver_connect_latency_; + qr_code_receiver_connect_latency_ = nullptr; + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_EstablishConnection::_internal_mutable_qr_code_receiver_connect_latency() { + _has_bits_[0] |= 0x00000004u; + if (qr_code_receiver_connect_latency_ == nullptr) { + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(GetArenaForAllocation()); + qr_code_receiver_connect_latency_ = p; + } + return qr_code_receiver_connect_latency_; +} +inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_EstablishConnection::mutable_qr_code_receiver_connect_latency() { + ::PROTOBUF_NAMESPACE_ID::Duration* _msg = _internal_mutable_qr_code_receiver_connect_latency(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.EstablishConnection.qr_code_receiver_connect_latency) + return _msg; +} +inline void SharingLog_EstablishConnection::set_allocated_qr_code_receiver_connect_latency(::PROTOBUF_NAMESPACE_ID::Duration* qr_code_receiver_connect_latency) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(qr_code_receiver_connect_latency_); + } + if (qr_code_receiver_connect_latency) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qr_code_receiver_connect_latency)); + if (message_arena != submessage_arena) { + qr_code_receiver_connect_latency = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, qr_code_receiver_connect_latency, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + qr_code_receiver_connect_latency_ = qr_code_receiver_connect_latency; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.EstablishConnection.qr_code_receiver_connect_latency) +} + // ------------------------------------------------------------------- // SharingLog_AcceptAgreements @@ -16100,6 +19900,34 @@ inline void SharingLog_ScanForShareTargetsStart::set_allocated_referrer_name(std // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.ScanForShareTargetsStart.referrer_name) } +// optional bool use_qr_code = 6; +inline bool SharingLog_ScanForShareTargetsStart::_internal_has_use_qr_code() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool SharingLog_ScanForShareTargetsStart::has_use_qr_code() const { + return _internal_has_use_qr_code(); +} +inline void SharingLog_ScanForShareTargetsStart::clear_use_qr_code() { + use_qr_code_ = false; + _has_bits_[0] &= ~0x00000020u; +} +inline bool SharingLog_ScanForShareTargetsStart::_internal_use_qr_code() const { + return use_qr_code_; +} +inline bool SharingLog_ScanForShareTargetsStart::use_qr_code() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ScanForShareTargetsStart.use_qr_code) + return _internal_use_qr_code(); +} +inline void SharingLog_ScanForShareTargetsStart::_internal_set_use_qr_code(bool value) { + _has_bits_[0] |= 0x00000020u; + use_qr_code_ = value; +} +inline void SharingLog_ScanForShareTargetsStart::set_use_qr_code(bool value) { + _internal_set_use_qr_code(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ScanForShareTargetsStart.use_qr_code) +} + // ------------------------------------------------------------------- // SharingLog_ScanForShareTargetsEnd @@ -16543,7 +20371,7 @@ inline void SharingLog_ReceiveFastInitialization::set_notifications_filtered(boo // optional .location.nearby.proto.sharing.SharingUseCase use_case = 1; inline bool SharingLog_EventMetadata::_internal_has_use_case() const { - bool value = (_has_bits_[0] & 0x00000001u) != 0; + bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool SharingLog_EventMetadata::has_use_case() const { @@ -16551,7 +20379,7 @@ inline bool SharingLog_EventMetadata::has_use_case() const { } inline void SharingLog_EventMetadata::clear_use_case() { use_case_ = 0; - _has_bits_[0] &= ~0x00000001u; + _has_bits_[0] &= ~0x00000010u; } inline ::location::nearby::proto::sharing::SharingUseCase SharingLog_EventMetadata::_internal_use_case() const { return static_cast< ::location::nearby::proto::sharing::SharingUseCase >(use_case_); @@ -16562,7 +20390,7 @@ inline ::location::nearby::proto::sharing::SharingUseCase SharingLog_EventMetada } inline void SharingLog_EventMetadata::_internal_set_use_case(::location::nearby::proto::sharing::SharingUseCase value) { assert(::location::nearby::proto::sharing::SharingUseCase_IsValid(value)); - _has_bits_[0] |= 0x00000001u; + _has_bits_[0] |= 0x00000010u; use_case_ = value; } inline void SharingLog_EventMetadata::set_use_case(::location::nearby::proto::sharing::SharingUseCase value) { @@ -16570,9 +20398,9 @@ inline void SharingLog_EventMetadata::set_use_case(::location::nearby::proto::sh // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.EventMetadata.use_case) } -// optional bool initial_opt_in = 2; +// optional bool initial_opt_in = 2 [deprecated = true]; inline bool SharingLog_EventMetadata::_internal_has_initial_opt_in() const { - bool value = (_has_bits_[0] & 0x00000002u) != 0; + bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool SharingLog_EventMetadata::has_initial_opt_in() const { @@ -16580,7 +20408,7 @@ inline bool SharingLog_EventMetadata::has_initial_opt_in() const { } inline void SharingLog_EventMetadata::clear_initial_opt_in() { initial_opt_in_ = false; - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000020u; } inline bool SharingLog_EventMetadata::_internal_initial_opt_in() const { return initial_opt_in_; @@ -16590,7 +20418,7 @@ inline bool SharingLog_EventMetadata::initial_opt_in() const { return _internal_initial_opt_in(); } inline void SharingLog_EventMetadata::_internal_set_initial_opt_in(bool value) { - _has_bits_[0] |= 0x00000002u; + _has_bits_[0] |= 0x00000020u; initial_opt_in_ = value; } inline void SharingLog_EventMetadata::set_initial_opt_in(bool value) { @@ -16598,9 +20426,9 @@ inline void SharingLog_EventMetadata::set_initial_opt_in(bool value) { // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.EventMetadata.initial_opt_in) } -// optional bool opt_in = 3; +// optional bool opt_in = 3 [deprecated = true]; inline bool SharingLog_EventMetadata::_internal_has_opt_in() const { - bool value = (_has_bits_[0] & 0x00000004u) != 0; + bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool SharingLog_EventMetadata::has_opt_in() const { @@ -16608,7 +20436,7 @@ inline bool SharingLog_EventMetadata::has_opt_in() const { } inline void SharingLog_EventMetadata::clear_opt_in() { opt_in_ = false; - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000040u; } inline bool SharingLog_EventMetadata::_internal_opt_in() const { return opt_in_; @@ -16618,7 +20446,7 @@ inline bool SharingLog_EventMetadata::opt_in() const { return _internal_opt_in(); } inline void SharingLog_EventMetadata::_internal_set_opt_in(bool value) { - _has_bits_[0] |= 0x00000004u; + _has_bits_[0] |= 0x00000040u; opt_in_ = value; } inline void SharingLog_EventMetadata::set_opt_in(bool value) { @@ -16626,9 +20454,9 @@ inline void SharingLog_EventMetadata::set_opt_in(bool value) { // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.EventMetadata.opt_in) } -// optional bool initial_enable_status = 4; +// optional bool initial_enable_status = 4 [deprecated = true]; inline bool SharingLog_EventMetadata::_internal_has_initial_enable_status() const { - bool value = (_has_bits_[0] & 0x00000008u) != 0; + bool value = (_has_bits_[0] & 0x00000080u) != 0; return value; } inline bool SharingLog_EventMetadata::has_initial_enable_status() const { @@ -16636,7 +20464,7 @@ inline bool SharingLog_EventMetadata::has_initial_enable_status() const { } inline void SharingLog_EventMetadata::clear_initial_enable_status() { initial_enable_status_ = false; - _has_bits_[0] &= ~0x00000008u; + _has_bits_[0] &= ~0x00000080u; } inline bool SharingLog_EventMetadata::_internal_initial_enable_status() const { return initial_enable_status_; @@ -16646,7 +20474,7 @@ inline bool SharingLog_EventMetadata::initial_enable_status() const { return _internal_initial_enable_status(); } inline void SharingLog_EventMetadata::_internal_set_initial_enable_status(bool value) { - _has_bits_[0] |= 0x00000008u; + _has_bits_[0] |= 0x00000080u; initial_enable_status_ = value; } inline void SharingLog_EventMetadata::set_initial_enable_status(bool value) { @@ -16656,7 +20484,7 @@ inline void SharingLog_EventMetadata::set_initial_enable_status(bool value) { // optional int64 flow_id = 5; inline bool SharingLog_EventMetadata::_internal_has_flow_id() const { - bool value = (_has_bits_[0] & 0x00000010u) != 0; + bool value = (_has_bits_[0] & 0x00000100u) != 0; return value; } inline bool SharingLog_EventMetadata::has_flow_id() const { @@ -16664,7 +20492,7 @@ inline bool SharingLog_EventMetadata::has_flow_id() const { } inline void SharingLog_EventMetadata::clear_flow_id() { flow_id_ = int64_t{0}; - _has_bits_[0] &= ~0x00000010u; + _has_bits_[0] &= ~0x00000100u; } inline int64_t SharingLog_EventMetadata::_internal_flow_id() const { return flow_id_; @@ -16674,7 +20502,7 @@ inline int64_t SharingLog_EventMetadata::flow_id() const { return _internal_flow_id(); } inline void SharingLog_EventMetadata::_internal_set_flow_id(int64_t value) { - _has_bits_[0] |= 0x00000010u; + _has_bits_[0] |= 0x00000100u; flow_id_ = value; } inline void SharingLog_EventMetadata::set_flow_id(int64_t value) { @@ -16684,7 +20512,7 @@ inline void SharingLog_EventMetadata::set_flow_id(int64_t value) { // optional int64 session_id = 6; inline bool SharingLog_EventMetadata::_internal_has_session_id() const { - bool value = (_has_bits_[0] & 0x00000020u) != 0; + bool value = (_has_bits_[0] & 0x00000200u) != 0; return value; } inline bool SharingLog_EventMetadata::has_session_id() const { @@ -16692,7 +20520,7 @@ inline bool SharingLog_EventMetadata::has_session_id() const { } inline void SharingLog_EventMetadata::clear_session_id() { session_id_ = int64_t{0}; - _has_bits_[0] &= ~0x00000020u; + _has_bits_[0] &= ~0x00000200u; } inline int64_t SharingLog_EventMetadata::_internal_session_id() const { return session_id_; @@ -16702,7 +20530,7 @@ inline int64_t SharingLog_EventMetadata::session_id() const { return _internal_session_id(); } inline void SharingLog_EventMetadata::_internal_set_session_id(int64_t value) { - _has_bits_[0] |= 0x00000020u; + _has_bits_[0] |= 0x00000200u; session_id_ = value; } inline void SharingLog_EventMetadata::set_session_id(int64_t value) { @@ -16712,7 +20540,7 @@ inline void SharingLog_EventMetadata::set_session_id(int64_t value) { // optional int32 vendor_id = 7; inline bool SharingLog_EventMetadata::_internal_has_vendor_id() const { - bool value = (_has_bits_[0] & 0x00000040u) != 0; + bool value = (_has_bits_[0] & 0x00000400u) != 0; return value; } inline bool SharingLog_EventMetadata::has_vendor_id() const { @@ -16720,7 +20548,7 @@ inline bool SharingLog_EventMetadata::has_vendor_id() const { } inline void SharingLog_EventMetadata::clear_vendor_id() { vendor_id_ = 0; - _has_bits_[0] &= ~0x00000040u; + _has_bits_[0] &= ~0x00000400u; } inline int32_t SharingLog_EventMetadata::_internal_vendor_id() const { return vendor_id_; @@ -16730,7 +20558,7 @@ inline int32_t SharingLog_EventMetadata::vendor_id() const { return _internal_vendor_id(); } inline void SharingLog_EventMetadata::_internal_set_vendor_id(int32_t value) { - _has_bits_[0] |= 0x00000040u; + _has_bits_[0] |= 0x00000400u; vendor_id_ = value; } inline void SharingLog_EventMetadata::set_vendor_id(int32_t value) { @@ -16738,13 +20566,289 @@ inline void SharingLog_EventMetadata::set_vendor_id(int32_t value) { // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.EventMetadata.vendor_id) } +// optional string cloud_sharing_id = 8; +inline bool SharingLog_EventMetadata::_internal_has_cloud_sharing_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_EventMetadata::has_cloud_sharing_id() const { + return _internal_has_cloud_sharing_id(); +} +inline void SharingLog_EventMetadata::clear_cloud_sharing_id() { + cloud_sharing_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SharingLog_EventMetadata::cloud_sharing_id() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_sharing_id) + return _internal_cloud_sharing_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SharingLog_EventMetadata::set_cloud_sharing_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + cloud_sharing_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_sharing_id) +} +inline std::string* SharingLog_EventMetadata::mutable_cloud_sharing_id() { + std::string* _s = _internal_mutable_cloud_sharing_id(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_sharing_id) + return _s; +} +inline const std::string& SharingLog_EventMetadata::_internal_cloud_sharing_id() const { + return cloud_sharing_id_.Get(); +} +inline void SharingLog_EventMetadata::_internal_set_cloud_sharing_id(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + cloud_sharing_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SharingLog_EventMetadata::_internal_mutable_cloud_sharing_id() { + _has_bits_[0] |= 0x00000001u; + return cloud_sharing_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SharingLog_EventMetadata::release_cloud_sharing_id() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_sharing_id) + if (!_internal_has_cloud_sharing_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = cloud_sharing_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (cloud_sharing_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + cloud_sharing_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SharingLog_EventMetadata::set_allocated_cloud_sharing_id(std::string* cloud_sharing_id) { + if (cloud_sharing_id != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + cloud_sharing_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cloud_sharing_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (cloud_sharing_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + cloud_sharing_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_sharing_id) +} + +// optional string cloud_receiver_session_id = 9; +inline bool SharingLog_EventMetadata::_internal_has_cloud_receiver_session_id() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_EventMetadata::has_cloud_receiver_session_id() const { + return _internal_has_cloud_receiver_session_id(); +} +inline void SharingLog_EventMetadata::clear_cloud_receiver_session_id() { + cloud_receiver_session_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SharingLog_EventMetadata::cloud_receiver_session_id() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_receiver_session_id) + return _internal_cloud_receiver_session_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SharingLog_EventMetadata::set_cloud_receiver_session_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + cloud_receiver_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_receiver_session_id) +} +inline std::string* SharingLog_EventMetadata::mutable_cloud_receiver_session_id() { + std::string* _s = _internal_mutable_cloud_receiver_session_id(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_receiver_session_id) + return _s; +} +inline const std::string& SharingLog_EventMetadata::_internal_cloud_receiver_session_id() const { + return cloud_receiver_session_id_.Get(); +} +inline void SharingLog_EventMetadata::_internal_set_cloud_receiver_session_id(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + cloud_receiver_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SharingLog_EventMetadata::_internal_mutable_cloud_receiver_session_id() { + _has_bits_[0] |= 0x00000002u; + return cloud_receiver_session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SharingLog_EventMetadata::release_cloud_receiver_session_id() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_receiver_session_id) + if (!_internal_has_cloud_receiver_session_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = cloud_receiver_session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (cloud_receiver_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + cloud_receiver_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SharingLog_EventMetadata::set_allocated_cloud_receiver_session_id(std::string* cloud_receiver_session_id) { + if (cloud_receiver_session_id != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + cloud_receiver_session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cloud_receiver_session_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (cloud_receiver_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + cloud_receiver_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.EventMetadata.cloud_receiver_session_id) +} + +// optional string external_provider_name = 10; +inline bool SharingLog_EventMetadata::_internal_has_external_provider_name() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SharingLog_EventMetadata::has_external_provider_name() const { + return _internal_has_external_provider_name(); +} +inline void SharingLog_EventMetadata::clear_external_provider_name() { + external_provider_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string& SharingLog_EventMetadata::external_provider_name() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_name) + return _internal_external_provider_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SharingLog_EventMetadata::set_external_provider_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + external_provider_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_name) +} +inline std::string* SharingLog_EventMetadata::mutable_external_provider_name() { + std::string* _s = _internal_mutable_external_provider_name(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_name) + return _s; +} +inline const std::string& SharingLog_EventMetadata::_internal_external_provider_name() const { + return external_provider_name_.Get(); +} +inline void SharingLog_EventMetadata::_internal_set_external_provider_name(const std::string& value) { + _has_bits_[0] |= 0x00000004u; + external_provider_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SharingLog_EventMetadata::_internal_mutable_external_provider_name() { + _has_bits_[0] |= 0x00000004u; + return external_provider_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SharingLog_EventMetadata::release_external_provider_name() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_name) + if (!_internal_has_external_provider_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto* p = external_provider_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (external_provider_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + external_provider_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SharingLog_EventMetadata::set_allocated_external_provider_name(std::string* external_provider_name) { + if (external_provider_name != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + external_provider_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), external_provider_name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (external_provider_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + external_provider_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_name) +} + +// optional string external_provider_id = 11; +inline bool SharingLog_EventMetadata::_internal_has_external_provider_id() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SharingLog_EventMetadata::has_external_provider_id() const { + return _internal_has_external_provider_id(); +} +inline void SharingLog_EventMetadata::clear_external_provider_id() { + external_provider_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string& SharingLog_EventMetadata::external_provider_id() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_id) + return _internal_external_provider_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SharingLog_EventMetadata::set_external_provider_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000008u; + external_provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_id) +} +inline std::string* SharingLog_EventMetadata::mutable_external_provider_id() { + std::string* _s = _internal_mutable_external_provider_id(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_id) + return _s; +} +inline const std::string& SharingLog_EventMetadata::_internal_external_provider_id() const { + return external_provider_id_.Get(); +} +inline void SharingLog_EventMetadata::_internal_set_external_provider_id(const std::string& value) { + _has_bits_[0] |= 0x00000008u; + external_provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SharingLog_EventMetadata::_internal_mutable_external_provider_id() { + _has_bits_[0] |= 0x00000008u; + return external_provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SharingLog_EventMetadata::release_external_provider_id() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_id) + if (!_internal_has_external_provider_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto* p = external_provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (external_provider_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + external_provider_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SharingLog_EventMetadata::set_allocated_external_provider_id(std::string* external_provider_id) { + if (external_provider_id != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + external_provider_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), external_provider_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (external_provider_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + external_provider_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.EventMetadata.external_provider_id) +} + // ------------------------------------------------------------------- // SharingLog_DiscoverShareTarget // optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; inline bool SharingLog_DiscoverShareTarget::_internal_has_share_target_info() const { - bool value = (_has_bits_[0] & 0x00000002u) != 0; + bool value = (_has_bits_[0] & 0x00000004u) != 0; PROTOBUF_ASSUME(!value || share_target_info_ != nullptr); return value; } @@ -16753,7 +20857,7 @@ inline bool SharingLog_DiscoverShareTarget::has_share_target_info() const { } inline void SharingLog_DiscoverShareTarget::clear_share_target_info() { if (share_target_info_ != nullptr) share_target_info_->Clear(); - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000004u; } inline const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& SharingLog_DiscoverShareTarget::_internal_share_target_info() const { const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* p = share_target_info_; @@ -16771,14 +20875,14 @@ inline void SharingLog_DiscoverShareTarget::unsafe_arena_set_allocated_share_tar } share_target_info_ = share_target_info; if (share_target_info) { - _has_bits_[0] |= 0x00000002u; + _has_bits_[0] |= 0x00000004u; } else { - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000004u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.share_target_info) } inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_DiscoverShareTarget::release_share_target_info() { - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000004u; ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* temp = share_target_info_; share_target_info_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE @@ -16794,13 +20898,13 @@ inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingL } inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_DiscoverShareTarget::unsafe_arena_release_share_target_info() { // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.share_target_info) - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000004u; ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* temp = share_target_info_; share_target_info_ = nullptr; return temp; } inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_DiscoverShareTarget::_internal_mutable_share_target_info() { - _has_bits_[0] |= 0x00000002u; + _has_bits_[0] |= 0x00000004u; if (share_target_info_ == nullptr) { auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo>(GetArenaForAllocation()); share_target_info_ = p; @@ -16824,9 +20928,9 @@ inline void SharingLog_DiscoverShareTarget::set_allocated_share_target_info(::ne share_target_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, share_target_info, submessage_arena); } - _has_bits_[0] |= 0x00000002u; + _has_bits_[0] |= 0x00000004u; } else { - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000004u; } share_target_info_ = share_target_info; // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.share_target_info) @@ -16834,7 +20938,7 @@ inline void SharingLog_DiscoverShareTarget::set_allocated_share_target_info(::ne // optional .google.protobuf.Duration duration_since_scanning = 2; inline bool SharingLog_DiscoverShareTarget::_internal_has_duration_since_scanning() const { - bool value = (_has_bits_[0] & 0x00000004u) != 0; + bool value = (_has_bits_[0] & 0x00000008u) != 0; PROTOBUF_ASSUME(!value || duration_since_scanning_ != nullptr); return value; } @@ -16857,14 +20961,14 @@ inline void SharingLog_DiscoverShareTarget::unsafe_arena_set_allocated_duration_ } duration_since_scanning_ = duration_since_scanning; if (duration_since_scanning) { - _has_bits_[0] |= 0x00000004u; + _has_bits_[0] |= 0x00000008u; } else { - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000008u; } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.duration_since_scanning) } inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_DiscoverShareTarget::release_duration_since_scanning() { - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000008u; ::PROTOBUF_NAMESPACE_ID::Duration* temp = duration_since_scanning_; duration_since_scanning_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE @@ -16880,13 +20984,13 @@ inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_DiscoverShareTarget::releas } inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_DiscoverShareTarget::unsafe_arena_release_duration_since_scanning() { // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.duration_since_scanning) - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000008u; ::PROTOBUF_NAMESPACE_ID::Duration* temp = duration_since_scanning_; duration_since_scanning_ = nullptr; return temp; } inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_DiscoverShareTarget::_internal_mutable_duration_since_scanning() { - _has_bits_[0] |= 0x00000004u; + _has_bits_[0] |= 0x00000008u; if (duration_since_scanning_ == nullptr) { auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(GetArenaForAllocation()); duration_since_scanning_ = p; @@ -16912,9 +21016,9 @@ inline void SharingLog_DiscoverShareTarget::set_allocated_duration_since_scannin duration_since_scanning = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, duration_since_scanning, submessage_arena); } - _has_bits_[0] |= 0x00000004u; + _has_bits_[0] |= 0x00000008u; } else { - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000008u; } duration_since_scanning_ = duration_since_scanning; // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.duration_since_scanning) @@ -16922,7 +21026,7 @@ inline void SharingLog_DiscoverShareTarget::set_allocated_duration_since_scannin // optional int64 session_id = 3; inline bool SharingLog_DiscoverShareTarget::_internal_has_session_id() const { - bool value = (_has_bits_[0] & 0x00000008u) != 0; + bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool SharingLog_DiscoverShareTarget::has_session_id() const { @@ -16930,7 +21034,7 @@ inline bool SharingLog_DiscoverShareTarget::has_session_id() const { } inline void SharingLog_DiscoverShareTarget::clear_session_id() { session_id_ = int64_t{0}; - _has_bits_[0] &= ~0x00000008u; + _has_bits_[0] &= ~0x00000010u; } inline int64_t SharingLog_DiscoverShareTarget::_internal_session_id() const { return session_id_; @@ -16940,7 +21044,7 @@ inline int64_t SharingLog_DiscoverShareTarget::session_id() const { return _internal_session_id(); } inline void SharingLog_DiscoverShareTarget::_internal_set_session_id(int64_t value) { - _has_bits_[0] |= 0x00000008u; + _has_bits_[0] |= 0x00000010u; session_id_ = value; } inline void SharingLog_DiscoverShareTarget::set_session_id(int64_t value) { @@ -16950,7 +21054,7 @@ inline void SharingLog_DiscoverShareTarget::set_session_id(int64_t value) { // optional int64 flow_id = 4; inline bool SharingLog_DiscoverShareTarget::_internal_has_flow_id() const { - bool value = (_has_bits_[0] & 0x00000010u) != 0; + bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool SharingLog_DiscoverShareTarget::has_flow_id() const { @@ -16958,7 +21062,7 @@ inline bool SharingLog_DiscoverShareTarget::has_flow_id() const { } inline void SharingLog_DiscoverShareTarget::clear_flow_id() { flow_id_ = int64_t{0}; - _has_bits_[0] &= ~0x00000010u; + _has_bits_[0] &= ~0x00000020u; } inline int64_t SharingLog_DiscoverShareTarget::_internal_flow_id() const { return flow_id_; @@ -16968,7 +21072,7 @@ inline int64_t SharingLog_DiscoverShareTarget::flow_id() const { return _internal_flow_id(); } inline void SharingLog_DiscoverShareTarget::_internal_set_flow_id(int64_t value) { - _has_bits_[0] |= 0x00000010u; + _has_bits_[0] |= 0x00000020u; flow_id_ = value; } inline void SharingLog_DiscoverShareTarget::set_flow_id(int64_t value) { @@ -17047,7 +21151,7 @@ inline void SharingLog_DiscoverShareTarget::set_allocated_referrer_name(std::str // optional int64 latency_since_activity_start_millis = 6 [default = -1]; inline bool SharingLog_DiscoverShareTarget::_internal_has_latency_since_activity_start_millis() const { - bool value = (_has_bits_[0] & 0x00000040u) != 0; + bool value = (_has_bits_[0] & 0x00000080u) != 0; return value; } inline bool SharingLog_DiscoverShareTarget::has_latency_since_activity_start_millis() const { @@ -17055,7 +21159,7 @@ inline bool SharingLog_DiscoverShareTarget::has_latency_since_activity_start_mil } inline void SharingLog_DiscoverShareTarget::clear_latency_since_activity_start_millis() { latency_since_activity_start_millis_ = int64_t{-1}; - _has_bits_[0] &= ~0x00000040u; + _has_bits_[0] &= ~0x00000080u; } inline int64_t SharingLog_DiscoverShareTarget::_internal_latency_since_activity_start_millis() const { return latency_since_activity_start_millis_; @@ -17065,7 +21169,7 @@ inline int64_t SharingLog_DiscoverShareTarget::latency_since_activity_start_mill return _internal_latency_since_activity_start_millis(); } inline void SharingLog_DiscoverShareTarget::_internal_set_latency_since_activity_start_millis(int64_t value) { - _has_bits_[0] |= 0x00000040u; + _has_bits_[0] |= 0x00000080u; latency_since_activity_start_millis_ = value; } inline void SharingLog_DiscoverShareTarget::set_latency_since_activity_start_millis(int64_t value) { @@ -17075,7 +21179,7 @@ inline void SharingLog_DiscoverShareTarget::set_latency_since_activity_start_mil // optional .location.nearby.proto.sharing.ScanType scan_type = 7; inline bool SharingLog_DiscoverShareTarget::_internal_has_scan_type() const { - bool value = (_has_bits_[0] & 0x00000020u) != 0; + bool value = (_has_bits_[0] & 0x00000040u) != 0; return value; } inline bool SharingLog_DiscoverShareTarget::has_scan_type() const { @@ -17083,7 +21187,7 @@ inline bool SharingLog_DiscoverShareTarget::has_scan_type() const { } inline void SharingLog_DiscoverShareTarget::clear_scan_type() { scan_type_ = 0; - _has_bits_[0] &= ~0x00000020u; + _has_bits_[0] &= ~0x00000040u; } inline ::location::nearby::proto::sharing::ScanType SharingLog_DiscoverShareTarget::_internal_scan_type() const { return static_cast< ::location::nearby::proto::sharing::ScanType >(scan_type_); @@ -17094,7 +21198,7 @@ inline ::location::nearby::proto::sharing::ScanType SharingLog_DiscoverShareTarg } inline void SharingLog_DiscoverShareTarget::_internal_set_scan_type(::location::nearby::proto::sharing::ScanType value) { assert(::location::nearby::proto::sharing::ScanType_IsValid(value)); - _has_bits_[0] |= 0x00000020u; + _has_bits_[0] |= 0x00000040u; scan_type_ = value; } inline void SharingLog_DiscoverShareTarget::set_scan_type(::location::nearby::proto::sharing::ScanType value) { @@ -17102,6 +21206,75 @@ inline void SharingLog_DiscoverShareTarget::set_scan_type(::location::nearby::pr // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.scan_type) } +// optional string cloud_receiver_session_id = 8; +inline bool SharingLog_DiscoverShareTarget::_internal_has_cloud_receiver_session_id() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_DiscoverShareTarget::has_cloud_receiver_session_id() const { + return _internal_has_cloud_receiver_session_id(); +} +inline void SharingLog_DiscoverShareTarget::clear_cloud_receiver_session_id() { + cloud_receiver_session_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SharingLog_DiscoverShareTarget::cloud_receiver_session_id() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.cloud_receiver_session_id) + return _internal_cloud_receiver_session_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SharingLog_DiscoverShareTarget::set_cloud_receiver_session_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + cloud_receiver_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.cloud_receiver_session_id) +} +inline std::string* SharingLog_DiscoverShareTarget::mutable_cloud_receiver_session_id() { + std::string* _s = _internal_mutable_cloud_receiver_session_id(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.cloud_receiver_session_id) + return _s; +} +inline const std::string& SharingLog_DiscoverShareTarget::_internal_cloud_receiver_session_id() const { + return cloud_receiver_session_id_.Get(); +} +inline void SharingLog_DiscoverShareTarget::_internal_set_cloud_receiver_session_id(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + cloud_receiver_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SharingLog_DiscoverShareTarget::_internal_mutable_cloud_receiver_session_id() { + _has_bits_[0] |= 0x00000002u; + return cloud_receiver_session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SharingLog_DiscoverShareTarget::release_cloud_receiver_session_id() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.cloud_receiver_session_id) + if (!_internal_has_cloud_receiver_session_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = cloud_receiver_session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (cloud_receiver_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + cloud_receiver_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SharingLog_DiscoverShareTarget::set_allocated_cloud_receiver_session_id(std::string* cloud_receiver_session_id) { + if (cloud_receiver_session_id != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + cloud_receiver_session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cloud_receiver_session_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (cloud_receiver_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + cloud_receiver_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.DiscoverShareTarget.cloud_receiver_session_id) +} + // ------------------------------------------------------------------- // SharingLog_ParsingFailedEndpointId @@ -17685,6 +21858,94 @@ inline void SharingLog_DescribeAttachments::set_allocated_attachments_info(::nea // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.DescribeAttachments.attachments_info) } +// optional .google.protobuf.Duration download_duration = 2; +inline bool SharingLog_DescribeAttachments::_internal_has_download_duration() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || download_duration_ != nullptr); + return value; +} +inline bool SharingLog_DescribeAttachments::has_download_duration() const { + return _internal_has_download_duration(); +} +inline const ::PROTOBUF_NAMESPACE_ID::Duration& SharingLog_DescribeAttachments::_internal_download_duration() const { + const ::PROTOBUF_NAMESPACE_ID::Duration* p = download_duration_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Duration_default_instance_); +} +inline const ::PROTOBUF_NAMESPACE_ID::Duration& SharingLog_DescribeAttachments::download_duration() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.DescribeAttachments.download_duration) + return _internal_download_duration(); +} +inline void SharingLog_DescribeAttachments::unsafe_arena_set_allocated_download_duration( + ::PROTOBUF_NAMESPACE_ID::Duration* download_duration) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(download_duration_); + } + download_duration_ = download_duration; + if (download_duration) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.DescribeAttachments.download_duration) +} +inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_DescribeAttachments::release_download_duration() { + _has_bits_[0] &= ~0x00000002u; + ::PROTOBUF_NAMESPACE_ID::Duration* temp = download_duration_; + download_duration_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_DescribeAttachments::unsafe_arena_release_download_duration() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.DescribeAttachments.download_duration) + _has_bits_[0] &= ~0x00000002u; + ::PROTOBUF_NAMESPACE_ID::Duration* temp = download_duration_; + download_duration_ = nullptr; + return temp; +} +inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_DescribeAttachments::_internal_mutable_download_duration() { + _has_bits_[0] |= 0x00000002u; + if (download_duration_ == nullptr) { + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Duration>(GetArenaForAllocation()); + download_duration_ = p; + } + return download_duration_; +} +inline ::PROTOBUF_NAMESPACE_ID::Duration* SharingLog_DescribeAttachments::mutable_download_duration() { + ::PROTOBUF_NAMESPACE_ID::Duration* _msg = _internal_mutable_download_duration(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.DescribeAttachments.download_duration) + return _msg; +} +inline void SharingLog_DescribeAttachments::set_allocated_download_duration(::PROTOBUF_NAMESPACE_ID::Duration* download_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(download_duration_); + } + if (download_duration) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(download_duration)); + if (message_arena != submessage_arena) { + download_duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, download_duration, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + download_duration_ = download_duration; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.DescribeAttachments.download_duration) +} + // ------------------------------------------------------------------- // SharingLog_SendIntroduction @@ -18149,7 +22410,7 @@ inline void SharingLog_RespondToIntroduction::set_qr_code_flow(bool value) { // optional int64 session_id = 1; inline bool SharingLog_SendAttachmentsStart::_internal_has_session_id() const { - bool value = (_has_bits_[0] & 0x00000002u) != 0; + bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool SharingLog_SendAttachmentsStart::has_session_id() const { @@ -18157,7 +22418,7 @@ inline bool SharingLog_SendAttachmentsStart::has_session_id() const { } inline void SharingLog_SendAttachmentsStart::clear_session_id() { session_id_ = int64_t{0}; - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000004u; } inline int64_t SharingLog_SendAttachmentsStart::_internal_session_id() const { return session_id_; @@ -18167,7 +22428,7 @@ inline int64_t SharingLog_SendAttachmentsStart::session_id() const { return _internal_session_id(); } inline void SharingLog_SendAttachmentsStart::_internal_set_session_id(int64_t value) { - _has_bits_[0] |= 0x00000002u; + _has_bits_[0] |= 0x00000004u; session_id_ = value; } inline void SharingLog_SendAttachmentsStart::set_session_id(int64_t value) { @@ -18267,7 +22528,7 @@ inline void SharingLog_SendAttachmentsStart::set_allocated_attachments_info(::ne // optional int32 transfer_position = 3; inline bool SharingLog_SendAttachmentsStart::_internal_has_transfer_position() const { - bool value = (_has_bits_[0] & 0x00000004u) != 0; + bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool SharingLog_SendAttachmentsStart::has_transfer_position() const { @@ -18275,7 +22536,7 @@ inline bool SharingLog_SendAttachmentsStart::has_transfer_position() const { } inline void SharingLog_SendAttachmentsStart::clear_transfer_position() { transfer_position_ = 0; - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000008u; } inline int32_t SharingLog_SendAttachmentsStart::_internal_transfer_position() const { return transfer_position_; @@ -18285,7 +22546,7 @@ inline int32_t SharingLog_SendAttachmentsStart::transfer_position() const { return _internal_transfer_position(); } inline void SharingLog_SendAttachmentsStart::_internal_set_transfer_position(int32_t value) { - _has_bits_[0] |= 0x00000004u; + _has_bits_[0] |= 0x00000008u; transfer_position_ = value; } inline void SharingLog_SendAttachmentsStart::set_transfer_position(int32_t value) { @@ -18295,7 +22556,7 @@ inline void SharingLog_SendAttachmentsStart::set_transfer_position(int32_t value // optional int32 concurrent_connections = 4; inline bool SharingLog_SendAttachmentsStart::_internal_has_concurrent_connections() const { - bool value = (_has_bits_[0] & 0x00000008u) != 0; + bool value = (_has_bits_[0] & 0x00000010u) != 0; return value; } inline bool SharingLog_SendAttachmentsStart::has_concurrent_connections() const { @@ -18303,7 +22564,7 @@ inline bool SharingLog_SendAttachmentsStart::has_concurrent_connections() const } inline void SharingLog_SendAttachmentsStart::clear_concurrent_connections() { concurrent_connections_ = 0; - _has_bits_[0] &= ~0x00000008u; + _has_bits_[0] &= ~0x00000010u; } inline int32_t SharingLog_SendAttachmentsStart::_internal_concurrent_connections() const { return concurrent_connections_; @@ -18313,7 +22574,7 @@ inline int32_t SharingLog_SendAttachmentsStart::concurrent_connections() const { return _internal_concurrent_connections(); } inline void SharingLog_SendAttachmentsStart::_internal_set_concurrent_connections(int32_t value) { - _has_bits_[0] |= 0x00000008u; + _has_bits_[0] |= 0x00000010u; concurrent_connections_ = value; } inline void SharingLog_SendAttachmentsStart::set_concurrent_connections(int32_t value) { @@ -18321,9 +22582,9 @@ inline void SharingLog_SendAttachmentsStart::set_concurrent_connections(int32_t // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.concurrent_connections) } -// optional bool qr_code_flow = 5; +// optional bool qr_code_flow = 5 [deprecated = true]; inline bool SharingLog_SendAttachmentsStart::_internal_has_qr_code_flow() const { - bool value = (_has_bits_[0] & 0x00000010u) != 0; + bool value = (_has_bits_[0] & 0x00000020u) != 0; return value; } inline bool SharingLog_SendAttachmentsStart::has_qr_code_flow() const { @@ -18331,7 +22592,7 @@ inline bool SharingLog_SendAttachmentsStart::has_qr_code_flow() const { } inline void SharingLog_SendAttachmentsStart::clear_qr_code_flow() { qr_code_flow_ = false; - _has_bits_[0] &= ~0x00000010u; + _has_bits_[0] &= ~0x00000020u; } inline bool SharingLog_SendAttachmentsStart::_internal_qr_code_flow() const { return qr_code_flow_; @@ -18341,7 +22602,7 @@ inline bool SharingLog_SendAttachmentsStart::qr_code_flow() const { return _internal_qr_code_flow(); } inline void SharingLog_SendAttachmentsStart::_internal_set_qr_code_flow(bool value) { - _has_bits_[0] |= 0x00000010u; + _has_bits_[0] |= 0x00000020u; qr_code_flow_ = value; } inline void SharingLog_SendAttachmentsStart::set_qr_code_flow(bool value) { @@ -18349,6 +22610,152 @@ inline void SharingLog_SendAttachmentsStart::set_qr_code_flow(bool value) { // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.qr_code_flow) } +// optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 6; +inline bool SharingLog_SendAttachmentsStart::_internal_has_share_target_info() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || share_target_info_ != nullptr); + return value; +} +inline bool SharingLog_SendAttachmentsStart::has_share_target_info() const { + return _internal_has_share_target_info(); +} +inline void SharingLog_SendAttachmentsStart::clear_share_target_info() { + if (share_target_info_ != nullptr) share_target_info_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& SharingLog_SendAttachmentsStart::_internal_share_target_info() const { + const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* p = share_target_info_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_ShareTargetInfo_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& SharingLog_SendAttachmentsStart::share_target_info() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.share_target_info) + return _internal_share_target_info(); +} +inline void SharingLog_SendAttachmentsStart::unsafe_arena_set_allocated_share_target_info( + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(share_target_info_); + } + share_target_info_ = share_target_info; + if (share_target_info) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.share_target_info) +} +inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_SendAttachmentsStart::release_share_target_info() { + _has_bits_[0] &= ~0x00000002u; + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* temp = share_target_info_; + share_target_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 ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_SendAttachmentsStart::unsafe_arena_release_share_target_info() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.share_target_info) + _has_bits_[0] &= ~0x00000002u; + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* temp = share_target_info_; + share_target_info_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_SendAttachmentsStart::_internal_mutable_share_target_info() { + _has_bits_[0] |= 0x00000002u; + if (share_target_info_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo>(GetArenaForAllocation()); + share_target_info_ = p; + } + return share_target_info_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_SendAttachmentsStart::mutable_share_target_info() { + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* _msg = _internal_mutable_share_target_info(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.share_target_info) + return _msg; +} +inline void SharingLog_SendAttachmentsStart::set_allocated_share_target_info(::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete share_target_info_; + } + if (share_target_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo>::GetOwningArena(share_target_info); + if (message_arena != submessage_arena) { + share_target_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, share_target_info, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + share_target_info_ = share_target_info; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.share_target_info) +} + +// optional bool advanced_protection_enabled = 7; +inline bool SharingLog_SendAttachmentsStart::_internal_has_advanced_protection_enabled() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool SharingLog_SendAttachmentsStart::has_advanced_protection_enabled() const { + return _internal_has_advanced_protection_enabled(); +} +inline void SharingLog_SendAttachmentsStart::clear_advanced_protection_enabled() { + advanced_protection_enabled_ = false; + _has_bits_[0] &= ~0x00000040u; +} +inline bool SharingLog_SendAttachmentsStart::_internal_advanced_protection_enabled() const { + return advanced_protection_enabled_; +} +inline bool SharingLog_SendAttachmentsStart::advanced_protection_enabled() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.advanced_protection_enabled) + return _internal_advanced_protection_enabled(); +} +inline void SharingLog_SendAttachmentsStart::_internal_set_advanced_protection_enabled(bool value) { + _has_bits_[0] |= 0x00000040u; + advanced_protection_enabled_ = value; +} +inline void SharingLog_SendAttachmentsStart::set_advanced_protection_enabled(bool value) { + _internal_set_advanced_protection_enabled(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.advanced_protection_enabled) +} + +// optional bool advanced_protection_mismatch = 8; +inline bool SharingLog_SendAttachmentsStart::_internal_has_advanced_protection_mismatch() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool SharingLog_SendAttachmentsStart::has_advanced_protection_mismatch() const { + return _internal_has_advanced_protection_mismatch(); +} +inline void SharingLog_SendAttachmentsStart::clear_advanced_protection_mismatch() { + advanced_protection_mismatch_ = false; + _has_bits_[0] &= ~0x00000080u; +} +inline bool SharingLog_SendAttachmentsStart::_internal_advanced_protection_mismatch() const { + return advanced_protection_mismatch_; +} +inline bool SharingLog_SendAttachmentsStart::advanced_protection_mismatch() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.advanced_protection_mismatch) + return _internal_advanced_protection_mismatch(); +} +inline void SharingLog_SendAttachmentsStart::_internal_set_advanced_protection_mismatch(bool value) { + _has_bits_[0] |= 0x00000080u; + advanced_protection_mismatch_ = value; +} +inline void SharingLog_SendAttachmentsStart::set_advanced_protection_mismatch(bool value) { + _internal_set_advanced_protection_mismatch(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsStart.advanced_protection_mismatch) +} + // ------------------------------------------------------------------- // SharingLog_SendAttachmentsEnd @@ -18800,6 +23207,175 @@ inline void SharingLog_SendAttachmentsEnd::set_connection_layer_status(::locatio // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.connection_layer_status) } +// optional int32 first_successful_transfer_date = 11; +inline bool SharingLog_SendAttachmentsEnd::_internal_has_first_successful_transfer_date() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool SharingLog_SendAttachmentsEnd::has_first_successful_transfer_date() const { + return _internal_has_first_successful_transfer_date(); +} +inline void SharingLog_SendAttachmentsEnd::clear_first_successful_transfer_date() { + first_successful_transfer_date_ = 0; + _has_bits_[0] &= ~0x00000400u; +} +inline int32_t SharingLog_SendAttachmentsEnd::_internal_first_successful_transfer_date() const { + return first_successful_transfer_date_; +} +inline int32_t SharingLog_SendAttachmentsEnd::first_successful_transfer_date() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.first_successful_transfer_date) + return _internal_first_successful_transfer_date(); +} +inline void SharingLog_SendAttachmentsEnd::_internal_set_first_successful_transfer_date(int32_t value) { + _has_bits_[0] |= 0x00000400u; + first_successful_transfer_date_ = value; +} +inline void SharingLog_SendAttachmentsEnd::set_first_successful_transfer_date(int32_t value) { + _internal_set_first_successful_transfer_date(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.first_successful_transfer_date) +} + +// optional int32 previous_successful_transfer_date = 12; +inline bool SharingLog_SendAttachmentsEnd::_internal_has_previous_successful_transfer_date() const { + bool value = (_has_bits_[0] & 0x00000800u) != 0; + return value; +} +inline bool SharingLog_SendAttachmentsEnd::has_previous_successful_transfer_date() const { + return _internal_has_previous_successful_transfer_date(); +} +inline void SharingLog_SendAttachmentsEnd::clear_previous_successful_transfer_date() { + previous_successful_transfer_date_ = 0; + _has_bits_[0] &= ~0x00000800u; +} +inline int32_t SharingLog_SendAttachmentsEnd::_internal_previous_successful_transfer_date() const { + return previous_successful_transfer_date_; +} +inline int32_t SharingLog_SendAttachmentsEnd::previous_successful_transfer_date() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.previous_successful_transfer_date) + return _internal_previous_successful_transfer_date(); +} +inline void SharingLog_SendAttachmentsEnd::_internal_set_previous_successful_transfer_date(int32_t value) { + _has_bits_[0] |= 0x00000800u; + previous_successful_transfer_date_ = value; +} +inline void SharingLog_SendAttachmentsEnd::set_previous_successful_transfer_date(int32_t value) { + _internal_set_previous_successful_transfer_date(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.previous_successful_transfer_date) +} + +// optional int32 lifetime_transfer_count = 13; +inline bool SharingLog_SendAttachmentsEnd::_internal_has_lifetime_transfer_count() const { + bool value = (_has_bits_[0] & 0x00001000u) != 0; + return value; +} +inline bool SharingLog_SendAttachmentsEnd::has_lifetime_transfer_count() const { + return _internal_has_lifetime_transfer_count(); +} +inline void SharingLog_SendAttachmentsEnd::clear_lifetime_transfer_count() { + lifetime_transfer_count_ = 0; + _has_bits_[0] &= ~0x00001000u; +} +inline int32_t SharingLog_SendAttachmentsEnd::_internal_lifetime_transfer_count() const { + return lifetime_transfer_count_; +} +inline int32_t SharingLog_SendAttachmentsEnd::lifetime_transfer_count() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.lifetime_transfer_count) + return _internal_lifetime_transfer_count(); +} +inline void SharingLog_SendAttachmentsEnd::_internal_set_lifetime_transfer_count(int32_t value) { + _has_bits_[0] |= 0x00001000u; + lifetime_transfer_count_ = value; +} +inline void SharingLog_SendAttachmentsEnd::set_lifetime_transfer_count(int32_t value) { + _internal_set_lifetime_transfer_count(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.lifetime_transfer_count) +} + +// optional int32 connection_medium = 14; +inline bool SharingLog_SendAttachmentsEnd::_internal_has_connection_medium() const { + bool value = (_has_bits_[0] & 0x00002000u) != 0; + return value; +} +inline bool SharingLog_SendAttachmentsEnd::has_connection_medium() const { + return _internal_has_connection_medium(); +} +inline void SharingLog_SendAttachmentsEnd::clear_connection_medium() { + connection_medium_ = 0; + _has_bits_[0] &= ~0x00002000u; +} +inline int32_t SharingLog_SendAttachmentsEnd::_internal_connection_medium() const { + return connection_medium_; +} +inline int32_t SharingLog_SendAttachmentsEnd::connection_medium() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.connection_medium) + return _internal_connection_medium(); +} +inline void SharingLog_SendAttachmentsEnd::_internal_set_connection_medium(int32_t value) { + _has_bits_[0] |= 0x00002000u; + connection_medium_ = value; +} +inline void SharingLog_SendAttachmentsEnd::set_connection_medium(int32_t value) { + _internal_set_connection_medium(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.connection_medium) +} + +// optional .location.nearby.proto.sharing.DataUsage data_usage = 15; +inline bool SharingLog_SendAttachmentsEnd::_internal_has_data_usage() const { + bool value = (_has_bits_[0] & 0x00004000u) != 0; + return value; +} +inline bool SharingLog_SendAttachmentsEnd::has_data_usage() const { + return _internal_has_data_usage(); +} +inline void SharingLog_SendAttachmentsEnd::clear_data_usage() { + data_usage_ = 0; + _has_bits_[0] &= ~0x00004000u; +} +inline ::location::nearby::proto::sharing::DataUsage SharingLog_SendAttachmentsEnd::_internal_data_usage() const { + return static_cast< ::location::nearby::proto::sharing::DataUsage >(data_usage_); +} +inline ::location::nearby::proto::sharing::DataUsage SharingLog_SendAttachmentsEnd::data_usage() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.data_usage) + return _internal_data_usage(); +} +inline void SharingLog_SendAttachmentsEnd::_internal_set_data_usage(::location::nearby::proto::sharing::DataUsage value) { + assert(::location::nearby::proto::sharing::DataUsage_IsValid(value)); + _has_bits_[0] |= 0x00004000u; + data_usage_ = value; +} +inline void SharingLog_SendAttachmentsEnd::set_data_usage(::location::nearby::proto::sharing::DataUsage value) { + _internal_set_data_usage(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.data_usage) +} + +// optional bool is_mutual_contact = 16; +inline bool SharingLog_SendAttachmentsEnd::_internal_has_is_mutual_contact() const { + bool value = (_has_bits_[0] & 0x00008000u) != 0; + return value; +} +inline bool SharingLog_SendAttachmentsEnd::has_is_mutual_contact() const { + return _internal_has_is_mutual_contact(); +} +inline void SharingLog_SendAttachmentsEnd::clear_is_mutual_contact() { + is_mutual_contact_ = false; + _has_bits_[0] &= ~0x00008000u; +} +inline bool SharingLog_SendAttachmentsEnd::_internal_is_mutual_contact() const { + return is_mutual_contact_; +} +inline bool SharingLog_SendAttachmentsEnd::is_mutual_contact() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.is_mutual_contact) + return _internal_is_mutual_contact(); +} +inline void SharingLog_SendAttachmentsEnd::_internal_set_is_mutual_contact(bool value) { + _has_bits_[0] |= 0x00008000u; + is_mutual_contact_ = value; +} +inline void SharingLog_SendAttachmentsEnd::set_is_mutual_contact(bool value) { + _internal_set_is_mutual_contact(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SendAttachmentsEnd.is_mutual_contact) +} + // ------------------------------------------------------------------- // SharingLog_ReceiveAttachmentsStart @@ -19260,6 +23836,147 @@ inline void SharingLog_ReceiveAttachmentsEnd::set_allocated_share_target_info(:: // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.share_target_info) } +// optional int32 first_successful_transfer_date = 6; +inline bool SharingLog_ReceiveAttachmentsEnd::_internal_has_first_successful_transfer_date() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool SharingLog_ReceiveAttachmentsEnd::has_first_successful_transfer_date() const { + return _internal_has_first_successful_transfer_date(); +} +inline void SharingLog_ReceiveAttachmentsEnd::clear_first_successful_transfer_date() { + first_successful_transfer_date_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline int32_t SharingLog_ReceiveAttachmentsEnd::_internal_first_successful_transfer_date() const { + return first_successful_transfer_date_; +} +inline int32_t SharingLog_ReceiveAttachmentsEnd::first_successful_transfer_date() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.first_successful_transfer_date) + return _internal_first_successful_transfer_date(); +} +inline void SharingLog_ReceiveAttachmentsEnd::_internal_set_first_successful_transfer_date(int32_t value) { + _has_bits_[0] |= 0x00000020u; + first_successful_transfer_date_ = value; +} +inline void SharingLog_ReceiveAttachmentsEnd::set_first_successful_transfer_date(int32_t value) { + _internal_set_first_successful_transfer_date(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.first_successful_transfer_date) +} + +// optional int32 previous_successful_transfer_date = 7; +inline bool SharingLog_ReceiveAttachmentsEnd::_internal_has_previous_successful_transfer_date() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool SharingLog_ReceiveAttachmentsEnd::has_previous_successful_transfer_date() const { + return _internal_has_previous_successful_transfer_date(); +} +inline void SharingLog_ReceiveAttachmentsEnd::clear_previous_successful_transfer_date() { + previous_successful_transfer_date_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline int32_t SharingLog_ReceiveAttachmentsEnd::_internal_previous_successful_transfer_date() const { + return previous_successful_transfer_date_; +} +inline int32_t SharingLog_ReceiveAttachmentsEnd::previous_successful_transfer_date() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.previous_successful_transfer_date) + return _internal_previous_successful_transfer_date(); +} +inline void SharingLog_ReceiveAttachmentsEnd::_internal_set_previous_successful_transfer_date(int32_t value) { + _has_bits_[0] |= 0x00000040u; + previous_successful_transfer_date_ = value; +} +inline void SharingLog_ReceiveAttachmentsEnd::set_previous_successful_transfer_date(int32_t value) { + _internal_set_previous_successful_transfer_date(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.previous_successful_transfer_date) +} + +// optional int32 lifetime_transfer_count = 8; +inline bool SharingLog_ReceiveAttachmentsEnd::_internal_has_lifetime_transfer_count() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool SharingLog_ReceiveAttachmentsEnd::has_lifetime_transfer_count() const { + return _internal_has_lifetime_transfer_count(); +} +inline void SharingLog_ReceiveAttachmentsEnd::clear_lifetime_transfer_count() { + lifetime_transfer_count_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline int32_t SharingLog_ReceiveAttachmentsEnd::_internal_lifetime_transfer_count() const { + return lifetime_transfer_count_; +} +inline int32_t SharingLog_ReceiveAttachmentsEnd::lifetime_transfer_count() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.lifetime_transfer_count) + return _internal_lifetime_transfer_count(); +} +inline void SharingLog_ReceiveAttachmentsEnd::_internal_set_lifetime_transfer_count(int32_t value) { + _has_bits_[0] |= 0x00000080u; + lifetime_transfer_count_ = value; +} +inline void SharingLog_ReceiveAttachmentsEnd::set_lifetime_transfer_count(int32_t value) { + _internal_set_lifetime_transfer_count(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.lifetime_transfer_count) +} + +// optional int32 connection_medium = 14; +inline bool SharingLog_ReceiveAttachmentsEnd::_internal_has_connection_medium() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool SharingLog_ReceiveAttachmentsEnd::has_connection_medium() const { + return _internal_has_connection_medium(); +} +inline void SharingLog_ReceiveAttachmentsEnd::clear_connection_medium() { + connection_medium_ = 0; + _has_bits_[0] &= ~0x00000100u; +} +inline int32_t SharingLog_ReceiveAttachmentsEnd::_internal_connection_medium() const { + return connection_medium_; +} +inline int32_t SharingLog_ReceiveAttachmentsEnd::connection_medium() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.connection_medium) + return _internal_connection_medium(); +} +inline void SharingLog_ReceiveAttachmentsEnd::_internal_set_connection_medium(int32_t value) { + _has_bits_[0] |= 0x00000100u; + connection_medium_ = value; +} +inline void SharingLog_ReceiveAttachmentsEnd::set_connection_medium(int32_t value) { + _internal_set_connection_medium(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.connection_medium) +} + +// optional .location.nearby.proto.sharing.DataUsage data_usage = 15; +inline bool SharingLog_ReceiveAttachmentsEnd::_internal_has_data_usage() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool SharingLog_ReceiveAttachmentsEnd::has_data_usage() const { + return _internal_has_data_usage(); +} +inline void SharingLog_ReceiveAttachmentsEnd::clear_data_usage() { + data_usage_ = 0; + _has_bits_[0] &= ~0x00000200u; +} +inline ::location::nearby::proto::sharing::DataUsage SharingLog_ReceiveAttachmentsEnd::_internal_data_usage() const { + return static_cast< ::location::nearby::proto::sharing::DataUsage >(data_usage_); +} +inline ::location::nearby::proto::sharing::DataUsage SharingLog_ReceiveAttachmentsEnd::data_usage() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.data_usage) + return _internal_data_usage(); +} +inline void SharingLog_ReceiveAttachmentsEnd::_internal_set_data_usage(::location::nearby::proto::sharing::DataUsage value) { + assert(::location::nearby::proto::sharing::DataUsage_IsValid(value)); + _has_bits_[0] |= 0x00000200u; + data_usage_ = value; +} +inline void SharingLog_ReceiveAttachmentsEnd::set_data_usage(::location::nearby::proto::sharing::DataUsage value) { + _internal_set_data_usage(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ReceiveAttachmentsEnd.data_usage) +} + // ------------------------------------------------------------------- // SharingLog_CancelConnection @@ -21030,6 +25747,62 @@ inline void SharingLog_ShareTargetInfo::set_device_relationship(::location::near // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo.device_relationship) } +// optional bool has_matching_qr_code = 4; +inline bool SharingLog_ShareTargetInfo::_internal_has_has_matching_qr_code() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SharingLog_ShareTargetInfo::has_has_matching_qr_code() const { + return _internal_has_has_matching_qr_code(); +} +inline void SharingLog_ShareTargetInfo::clear_has_matching_qr_code() { + has_matching_qr_code_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool SharingLog_ShareTargetInfo::_internal_has_matching_qr_code() const { + return has_matching_qr_code_; +} +inline bool SharingLog_ShareTargetInfo::has_matching_qr_code() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo.has_matching_qr_code) + return _internal_has_matching_qr_code(); +} +inline void SharingLog_ShareTargetInfo::_internal_set_has_matching_qr_code(bool value) { + _has_bits_[0] |= 0x00000008u; + has_matching_qr_code_ = value; +} +inline void SharingLog_ShareTargetInfo::set_has_matching_qr_code(bool value) { + _internal_set_has_matching_qr_code(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo.has_matching_qr_code) +} + +// optional bool is_external = 5; +inline bool SharingLog_ShareTargetInfo::_internal_has_is_external() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool SharingLog_ShareTargetInfo::has_is_external() const { + return _internal_has_is_external(); +} +inline void SharingLog_ShareTargetInfo::clear_is_external() { + is_external_ = false; + _has_bits_[0] &= ~0x00000010u; +} +inline bool SharingLog_ShareTargetInfo::_internal_is_external() const { + return is_external_; +} +inline bool SharingLog_ShareTargetInfo::is_external() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo.is_external) + return _internal_is_external(); +} +inline void SharingLog_ShareTargetInfo::_internal_set_is_external(bool value) { + _has_bits_[0] |= 0x00000010u; + is_external_ = value; +} +inline void SharingLog_ShareTargetInfo::set_is_external(bool value) { + _internal_set_is_external(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo.is_external) +} + // ------------------------------------------------------------------- // SharingLog_AttachmentsInfo @@ -21946,6 +26719,474 @@ inline void SharingLog_StreamAttachment::set_source_type(::location::nearby::pro // ------------------------------------------------------------------- +// SharingLog_CloudAttachmentInfo + +// optional .location.nearby.proto.sharing.AttachmentTransmissionStatus status = 1; +inline bool SharingLog_CloudAttachmentInfo::_internal_has_status() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_CloudAttachmentInfo::has_status() const { + return _internal_has_status(); +} +inline void SharingLog_CloudAttachmentInfo::clear_status() { + status_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::location::nearby::proto::sharing::AttachmentTransmissionStatus SharingLog_CloudAttachmentInfo::_internal_status() const { + return static_cast< ::location::nearby::proto::sharing::AttachmentTransmissionStatus >(status_); +} +inline ::location::nearby::proto::sharing::AttachmentTransmissionStatus SharingLog_CloudAttachmentInfo::status() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.status) + return _internal_status(); +} +inline void SharingLog_CloudAttachmentInfo::_internal_set_status(::location::nearby::proto::sharing::AttachmentTransmissionStatus value) { + assert(::location::nearby::proto::sharing::AttachmentTransmissionStatus_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + status_ = value; +} +inline void SharingLog_CloudAttachmentInfo::set_status(::location::nearby::proto::sharing::AttachmentTransmissionStatus value) { + _internal_set_status(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.status) +} + +// .nearby.sharing.analytics.proto.SharingLog.TextAttachment text_attachment = 2; +inline bool SharingLog_CloudAttachmentInfo::_internal_has_text_attachment() const { + return CloudAttachment_case() == kTextAttachment; +} +inline bool SharingLog_CloudAttachmentInfo::has_text_attachment() const { + return _internal_has_text_attachment(); +} +inline void SharingLog_CloudAttachmentInfo::set_has_text_attachment() { + _oneof_case_[0] = kTextAttachment; +} +inline void SharingLog_CloudAttachmentInfo::clear_text_attachment() { + if (_internal_has_text_attachment()) { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.text_attachment_; + } + clear_has_CloudAttachment(); + } +} +inline ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* SharingLog_CloudAttachmentInfo::release_text_attachment() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.text_attachment) + if (_internal_has_text_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* temp = CloudAttachment_.text_attachment_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + CloudAttachment_.text_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::nearby::sharing::analytics::proto::SharingLog_TextAttachment& SharingLog_CloudAttachmentInfo::_internal_text_attachment() const { + return _internal_has_text_attachment() + ? *CloudAttachment_.text_attachment_ + : reinterpret_cast< ::nearby::sharing::analytics::proto::SharingLog_TextAttachment&>(::nearby::sharing::analytics::proto::_SharingLog_TextAttachment_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_TextAttachment& SharingLog_CloudAttachmentInfo::text_attachment() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.text_attachment) + return _internal_text_attachment(); +} +inline ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* SharingLog_CloudAttachmentInfo::unsafe_arena_release_text_attachment() { + // @@protoc_insertion_point(field_unsafe_arena_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.text_attachment) + if (_internal_has_text_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* temp = CloudAttachment_.text_attachment_; + CloudAttachment_.text_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void SharingLog_CloudAttachmentInfo::unsafe_arena_set_allocated_text_attachment(::nearby::sharing::analytics::proto::SharingLog_TextAttachment* text_attachment) { + clear_CloudAttachment(); + if (text_attachment) { + set_has_text_attachment(); + CloudAttachment_.text_attachment_ = text_attachment; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.text_attachment) +} +inline ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* SharingLog_CloudAttachmentInfo::_internal_mutable_text_attachment() { + if (!_internal_has_text_attachment()) { + clear_CloudAttachment(); + set_has_text_attachment(); + CloudAttachment_.text_attachment_ = CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_TextAttachment >(GetArenaForAllocation()); + } + return CloudAttachment_.text_attachment_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* SharingLog_CloudAttachmentInfo::mutable_text_attachment() { + ::nearby::sharing::analytics::proto::SharingLog_TextAttachment* _msg = _internal_mutable_text_attachment(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.text_attachment) + return _msg; +} + +// .nearby.sharing.analytics.proto.SharingLog.FileAttachment file_attachment = 3; +inline bool SharingLog_CloudAttachmentInfo::_internal_has_file_attachment() const { + return CloudAttachment_case() == kFileAttachment; +} +inline bool SharingLog_CloudAttachmentInfo::has_file_attachment() const { + return _internal_has_file_attachment(); +} +inline void SharingLog_CloudAttachmentInfo::set_has_file_attachment() { + _oneof_case_[0] = kFileAttachment; +} +inline void SharingLog_CloudAttachmentInfo::clear_file_attachment() { + if (_internal_has_file_attachment()) { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.file_attachment_; + } + clear_has_CloudAttachment(); + } +} +inline ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* SharingLog_CloudAttachmentInfo::release_file_attachment() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.file_attachment) + if (_internal_has_file_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* temp = CloudAttachment_.file_attachment_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + CloudAttachment_.file_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::nearby::sharing::analytics::proto::SharingLog_FileAttachment& SharingLog_CloudAttachmentInfo::_internal_file_attachment() const { + return _internal_has_file_attachment() + ? *CloudAttachment_.file_attachment_ + : reinterpret_cast< ::nearby::sharing::analytics::proto::SharingLog_FileAttachment&>(::nearby::sharing::analytics::proto::_SharingLog_FileAttachment_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_FileAttachment& SharingLog_CloudAttachmentInfo::file_attachment() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.file_attachment) + return _internal_file_attachment(); +} +inline ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* SharingLog_CloudAttachmentInfo::unsafe_arena_release_file_attachment() { + // @@protoc_insertion_point(field_unsafe_arena_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.file_attachment) + if (_internal_has_file_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* temp = CloudAttachment_.file_attachment_; + CloudAttachment_.file_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void SharingLog_CloudAttachmentInfo::unsafe_arena_set_allocated_file_attachment(::nearby::sharing::analytics::proto::SharingLog_FileAttachment* file_attachment) { + clear_CloudAttachment(); + if (file_attachment) { + set_has_file_attachment(); + CloudAttachment_.file_attachment_ = file_attachment; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.file_attachment) +} +inline ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* SharingLog_CloudAttachmentInfo::_internal_mutable_file_attachment() { + if (!_internal_has_file_attachment()) { + clear_CloudAttachment(); + set_has_file_attachment(); + CloudAttachment_.file_attachment_ = CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_FileAttachment >(GetArenaForAllocation()); + } + return CloudAttachment_.file_attachment_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* SharingLog_CloudAttachmentInfo::mutable_file_attachment() { + ::nearby::sharing::analytics::proto::SharingLog_FileAttachment* _msg = _internal_mutable_file_attachment(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.file_attachment) + return _msg; +} + +// .nearby.sharing.analytics.proto.SharingLog.WifiCredentialsAttachment wifi_credentials_attachment = 4; +inline bool SharingLog_CloudAttachmentInfo::_internal_has_wifi_credentials_attachment() const { + return CloudAttachment_case() == kWifiCredentialsAttachment; +} +inline bool SharingLog_CloudAttachmentInfo::has_wifi_credentials_attachment() const { + return _internal_has_wifi_credentials_attachment(); +} +inline void SharingLog_CloudAttachmentInfo::set_has_wifi_credentials_attachment() { + _oneof_case_[0] = kWifiCredentialsAttachment; +} +inline void SharingLog_CloudAttachmentInfo::clear_wifi_credentials_attachment() { + if (_internal_has_wifi_credentials_attachment()) { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.wifi_credentials_attachment_; + } + clear_has_CloudAttachment(); + } +} +inline ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* SharingLog_CloudAttachmentInfo::release_wifi_credentials_attachment() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.wifi_credentials_attachment) + if (_internal_has_wifi_credentials_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* temp = CloudAttachment_.wifi_credentials_attachment_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + CloudAttachment_.wifi_credentials_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment& SharingLog_CloudAttachmentInfo::_internal_wifi_credentials_attachment() const { + return _internal_has_wifi_credentials_attachment() + ? *CloudAttachment_.wifi_credentials_attachment_ + : reinterpret_cast< ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment&>(::nearby::sharing::analytics::proto::_SharingLog_WifiCredentialsAttachment_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment& SharingLog_CloudAttachmentInfo::wifi_credentials_attachment() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.wifi_credentials_attachment) + return _internal_wifi_credentials_attachment(); +} +inline ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* SharingLog_CloudAttachmentInfo::unsafe_arena_release_wifi_credentials_attachment() { + // @@protoc_insertion_point(field_unsafe_arena_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.wifi_credentials_attachment) + if (_internal_has_wifi_credentials_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* temp = CloudAttachment_.wifi_credentials_attachment_; + CloudAttachment_.wifi_credentials_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void SharingLog_CloudAttachmentInfo::unsafe_arena_set_allocated_wifi_credentials_attachment(::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* wifi_credentials_attachment) { + clear_CloudAttachment(); + if (wifi_credentials_attachment) { + set_has_wifi_credentials_attachment(); + CloudAttachment_.wifi_credentials_attachment_ = wifi_credentials_attachment; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.wifi_credentials_attachment) +} +inline ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* SharingLog_CloudAttachmentInfo::_internal_mutable_wifi_credentials_attachment() { + if (!_internal_has_wifi_credentials_attachment()) { + clear_CloudAttachment(); + set_has_wifi_credentials_attachment(); + CloudAttachment_.wifi_credentials_attachment_ = CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment >(GetArenaForAllocation()); + } + return CloudAttachment_.wifi_credentials_attachment_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* SharingLog_CloudAttachmentInfo::mutable_wifi_credentials_attachment() { + ::nearby::sharing::analytics::proto::SharingLog_WifiCredentialsAttachment* _msg = _internal_mutable_wifi_credentials_attachment(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.wifi_credentials_attachment) + return _msg; +} + +// .nearby.sharing.analytics.proto.SharingLog.AppAttachment app_attachment = 5; +inline bool SharingLog_CloudAttachmentInfo::_internal_has_app_attachment() const { + return CloudAttachment_case() == kAppAttachment; +} +inline bool SharingLog_CloudAttachmentInfo::has_app_attachment() const { + return _internal_has_app_attachment(); +} +inline void SharingLog_CloudAttachmentInfo::set_has_app_attachment() { + _oneof_case_[0] = kAppAttachment; +} +inline void SharingLog_CloudAttachmentInfo::clear_app_attachment() { + if (_internal_has_app_attachment()) { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.app_attachment_; + } + clear_has_CloudAttachment(); + } +} +inline ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* SharingLog_CloudAttachmentInfo::release_app_attachment() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.app_attachment) + if (_internal_has_app_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* temp = CloudAttachment_.app_attachment_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + CloudAttachment_.app_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::nearby::sharing::analytics::proto::SharingLog_AppAttachment& SharingLog_CloudAttachmentInfo::_internal_app_attachment() const { + return _internal_has_app_attachment() + ? *CloudAttachment_.app_attachment_ + : reinterpret_cast< ::nearby::sharing::analytics::proto::SharingLog_AppAttachment&>(::nearby::sharing::analytics::proto::_SharingLog_AppAttachment_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_AppAttachment& SharingLog_CloudAttachmentInfo::app_attachment() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.app_attachment) + return _internal_app_attachment(); +} +inline ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* SharingLog_CloudAttachmentInfo::unsafe_arena_release_app_attachment() { + // @@protoc_insertion_point(field_unsafe_arena_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.app_attachment) + if (_internal_has_app_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* temp = CloudAttachment_.app_attachment_; + CloudAttachment_.app_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void SharingLog_CloudAttachmentInfo::unsafe_arena_set_allocated_app_attachment(::nearby::sharing::analytics::proto::SharingLog_AppAttachment* app_attachment) { + clear_CloudAttachment(); + if (app_attachment) { + set_has_app_attachment(); + CloudAttachment_.app_attachment_ = app_attachment; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.app_attachment) +} +inline ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* SharingLog_CloudAttachmentInfo::_internal_mutable_app_attachment() { + if (!_internal_has_app_attachment()) { + clear_CloudAttachment(); + set_has_app_attachment(); + CloudAttachment_.app_attachment_ = CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_AppAttachment >(GetArenaForAllocation()); + } + return CloudAttachment_.app_attachment_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* SharingLog_CloudAttachmentInfo::mutable_app_attachment() { + ::nearby::sharing::analytics::proto::SharingLog_AppAttachment* _msg = _internal_mutable_app_attachment(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.app_attachment) + return _msg; +} + +// .nearby.sharing.analytics.proto.SharingLog.StreamAttachment stream_attachment = 6; +inline bool SharingLog_CloudAttachmentInfo::_internal_has_stream_attachment() const { + return CloudAttachment_case() == kStreamAttachment; +} +inline bool SharingLog_CloudAttachmentInfo::has_stream_attachment() const { + return _internal_has_stream_attachment(); +} +inline void SharingLog_CloudAttachmentInfo::set_has_stream_attachment() { + _oneof_case_[0] = kStreamAttachment; +} +inline void SharingLog_CloudAttachmentInfo::clear_stream_attachment() { + if (_internal_has_stream_attachment()) { + if (GetArenaForAllocation() == nullptr) { + delete CloudAttachment_.stream_attachment_; + } + clear_has_CloudAttachment(); + } +} +inline ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* SharingLog_CloudAttachmentInfo::release_stream_attachment() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.stream_attachment) + if (_internal_has_stream_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* temp = CloudAttachment_.stream_attachment_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + CloudAttachment_.stream_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment& SharingLog_CloudAttachmentInfo::_internal_stream_attachment() const { + return _internal_has_stream_attachment() + ? *CloudAttachment_.stream_attachment_ + : reinterpret_cast< ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment&>(::nearby::sharing::analytics::proto::_SharingLog_StreamAttachment_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment& SharingLog_CloudAttachmentInfo::stream_attachment() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.stream_attachment) + return _internal_stream_attachment(); +} +inline ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* SharingLog_CloudAttachmentInfo::unsafe_arena_release_stream_attachment() { + // @@protoc_insertion_point(field_unsafe_arena_release:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.stream_attachment) + if (_internal_has_stream_attachment()) { + clear_has_CloudAttachment(); + ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* temp = CloudAttachment_.stream_attachment_; + CloudAttachment_.stream_attachment_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void SharingLog_CloudAttachmentInfo::unsafe_arena_set_allocated_stream_attachment(::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* stream_attachment) { + clear_CloudAttachment(); + if (stream_attachment) { + set_has_stream_attachment(); + CloudAttachment_.stream_attachment_ = stream_attachment; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.stream_attachment) +} +inline ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* SharingLog_CloudAttachmentInfo::_internal_mutable_stream_attachment() { + if (!_internal_has_stream_attachment()) { + clear_CloudAttachment(); + set_has_stream_attachment(); + CloudAttachment_.stream_attachment_ = CreateMaybeMessage< ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment >(GetArenaForAllocation()); + } + return CloudAttachment_.stream_attachment_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* SharingLog_CloudAttachmentInfo::mutable_stream_attachment() { + ::nearby::sharing::analytics::proto::SharingLog_StreamAttachment* _msg = _internal_mutable_stream_attachment(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.stream_attachment) + return _msg; +} + +// optional int64 transferred_bytes = 7; +inline bool SharingLog_CloudAttachmentInfo::_internal_has_transferred_bytes() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_CloudAttachmentInfo::has_transferred_bytes() const { + return _internal_has_transferred_bytes(); +} +inline void SharingLog_CloudAttachmentInfo::clear_transferred_bytes() { + transferred_bytes_ = int64_t{0}; + _has_bits_[0] &= ~0x00000002u; +} +inline int64_t SharingLog_CloudAttachmentInfo::_internal_transferred_bytes() const { + return transferred_bytes_; +} +inline int64_t SharingLog_CloudAttachmentInfo::transferred_bytes() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.transferred_bytes) + return _internal_transferred_bytes(); +} +inline void SharingLog_CloudAttachmentInfo::_internal_set_transferred_bytes(int64_t value) { + _has_bits_[0] |= 0x00000002u; + transferred_bytes_ = value; +} +inline void SharingLog_CloudAttachmentInfo::set_transferred_bytes(int64_t value) { + _internal_set_transferred_bytes(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.transferred_bytes) +} + +// optional int64 duration_millis = 8; +inline bool SharingLog_CloudAttachmentInfo::_internal_has_duration_millis() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SharingLog_CloudAttachmentInfo::has_duration_millis() const { + return _internal_has_duration_millis(); +} +inline void SharingLog_CloudAttachmentInfo::clear_duration_millis() { + duration_millis_ = int64_t{0}; + _has_bits_[0] &= ~0x00000004u; +} +inline int64_t SharingLog_CloudAttachmentInfo::_internal_duration_millis() const { + return duration_millis_; +} +inline int64_t SharingLog_CloudAttachmentInfo::duration_millis() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.duration_millis) + return _internal_duration_millis(); +} +inline void SharingLog_CloudAttachmentInfo::_internal_set_duration_millis(int64_t value) { + _has_bits_[0] |= 0x00000004u; + duration_millis_ = value; +} +inline void SharingLog_CloudAttachmentInfo::set_duration_millis(int64_t value) { + _internal_set_duration_millis(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo.duration_millis) +} + +inline bool SharingLog_CloudAttachmentInfo::has_CloudAttachment() const { + return CloudAttachment_case() != CLOUDATTACHMENT_NOT_SET; +} +inline void SharingLog_CloudAttachmentInfo::clear_has_CloudAttachment() { + _oneof_case_[0] = CLOUDATTACHMENT_NOT_SET; +} +inline SharingLog_CloudAttachmentInfo::CloudAttachmentCase SharingLog_CloudAttachmentInfo::CloudAttachment_case() const { + return SharingLog_CloudAttachmentInfo::CloudAttachmentCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + // SharingLog_AppCrash // optional .location.nearby.proto.sharing.AppCrashReason crash_reason = 1; @@ -22010,6 +27251,35 @@ inline void SharingLog_SetupWizard::set_visibility(::location::nearby::proto::sh // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SetupWizard.visibility) } +// optional .location.nearby.proto.sharing.Visibility previous_visibility = 2; +inline bool SharingLog_SetupWizard::_internal_has_previous_visibility() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_SetupWizard::has_previous_visibility() const { + return _internal_has_previous_visibility(); +} +inline void SharingLog_SetupWizard::clear_previous_visibility() { + previous_visibility_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::location::nearby::proto::sharing::Visibility SharingLog_SetupWizard::_internal_previous_visibility() const { + return static_cast< ::location::nearby::proto::sharing::Visibility >(previous_visibility_); +} +inline ::location::nearby::proto::sharing::Visibility SharingLog_SetupWizard::previous_visibility() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.SetupWizard.previous_visibility) + return _internal_previous_visibility(); +} +inline void SharingLog_SetupWizard::_internal_set_previous_visibility(::location::nearby::proto::sharing::Visibility value) { + assert(::location::nearby::proto::sharing::Visibility_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + previous_visibility_ = value; +} +inline void SharingLog_SetupWizard::set_previous_visibility(::location::nearby::proto::sharing::Visibility value) { + _internal_set_previous_visibility(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.SetupWizard.previous_visibility) +} + // ------------------------------------------------------------------- // SharingLog_SendDesktopNotification @@ -22078,11 +27348,1436 @@ inline void SharingLog_SendDesktopTransferEvent::set_event(::location::nearby::p // ------------------------------------------------------------------- +// SharingLog_ShowWaitingForAccept + +// optional .location.nearby.proto.sharing.ButtonStatus button_status = 1; +inline bool SharingLog_ShowWaitingForAccept::_internal_has_button_status() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_ShowWaitingForAccept::has_button_status() const { + return _internal_has_button_status(); +} +inline void SharingLog_ShowWaitingForAccept::clear_button_status() { + button_status_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::location::nearby::proto::sharing::ButtonStatus SharingLog_ShowWaitingForAccept::_internal_button_status() const { + return static_cast< ::location::nearby::proto::sharing::ButtonStatus >(button_status_); +} +inline ::location::nearby::proto::sharing::ButtonStatus SharingLog_ShowWaitingForAccept::button_status() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept.button_status) + return _internal_button_status(); +} +inline void SharingLog_ShowWaitingForAccept::_internal_set_button_status(::location::nearby::proto::sharing::ButtonStatus value) { + assert(::location::nearby::proto::sharing::ButtonStatus_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + button_status_ = value; +} +inline void SharingLog_ShowWaitingForAccept::set_button_status(::location::nearby::proto::sharing::ButtonStatus value) { + _internal_set_button_status(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept.button_status) +} + +// ------------------------------------------------------------------- + +// SharingLog_HighQualityMediumSetup + +// optional .nearby.sharing.analytics.proto.SharingLog.ShareTargetInfo share_target_info = 1; +inline bool SharingLog_HighQualityMediumSetup::_internal_has_share_target_info() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || share_target_info_ != nullptr); + return value; +} +inline bool SharingLog_HighQualityMediumSetup::has_share_target_info() const { + return _internal_has_share_target_info(); +} +inline void SharingLog_HighQualityMediumSetup::clear_share_target_info() { + if (share_target_info_ != nullptr) share_target_info_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& SharingLog_HighQualityMediumSetup::_internal_share_target_info() const { + const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* p = share_target_info_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_ShareTargetInfo_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo& SharingLog_HighQualityMediumSetup::share_target_info() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.share_target_info) + return _internal_share_target_info(); +} +inline void SharingLog_HighQualityMediumSetup::unsafe_arena_set_allocated_share_target_info( + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(share_target_info_); + } + share_target_info_ = share_target_info; + if (share_target_info) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.share_target_info) +} +inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_HighQualityMediumSetup::release_share_target_info() { + _has_bits_[0] &= ~0x00000001u; + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* temp = share_target_info_; + share_target_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 ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_HighQualityMediumSetup::unsafe_arena_release_share_target_info() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.share_target_info) + _has_bits_[0] &= ~0x00000001u; + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* temp = share_target_info_; + share_target_info_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_HighQualityMediumSetup::_internal_mutable_share_target_info() { + _has_bits_[0] |= 0x00000001u; + if (share_target_info_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo>(GetArenaForAllocation()); + share_target_info_ = p; + } + return share_target_info_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* SharingLog_HighQualityMediumSetup::mutable_share_target_info() { + ::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* _msg = _internal_mutable_share_target_info(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.share_target_info) + return _msg; +} +inline void SharingLog_HighQualityMediumSetup::set_allocated_share_target_info(::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo* share_target_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete share_target_info_; + } + if (share_target_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_ShareTargetInfo>::GetOwningArena(share_target_info); + if (message_arena != submessage_arena) { + share_target_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, share_target_info, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + share_target_info_ = share_target_info; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.share_target_info) +} + +// optional int64 session_id = 2; +inline bool SharingLog_HighQualityMediumSetup::_internal_has_session_id() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_HighQualityMediumSetup::has_session_id() const { + return _internal_has_session_id(); +} +inline void SharingLog_HighQualityMediumSetup::clear_session_id() { + session_id_ = int64_t{0}; + _has_bits_[0] &= ~0x00000002u; +} +inline int64_t SharingLog_HighQualityMediumSetup::_internal_session_id() const { + return session_id_; +} +inline int64_t SharingLog_HighQualityMediumSetup::session_id() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.session_id) + return _internal_session_id(); +} +inline void SharingLog_HighQualityMediumSetup::_internal_set_session_id(int64_t value) { + _has_bits_[0] |= 0x00000002u; + session_id_ = value; +} +inline void SharingLog_HighQualityMediumSetup::set_session_id(int64_t value) { + _internal_set_session_id(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.session_id) +} + +// optional int64 duration_millis = 3; +inline bool SharingLog_HighQualityMediumSetup::_internal_has_duration_millis() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SharingLog_HighQualityMediumSetup::has_duration_millis() const { + return _internal_has_duration_millis(); +} +inline void SharingLog_HighQualityMediumSetup::clear_duration_millis() { + duration_millis_ = int64_t{0}; + _has_bits_[0] &= ~0x00000004u; +} +inline int64_t SharingLog_HighQualityMediumSetup::_internal_duration_millis() const { + return duration_millis_; +} +inline int64_t SharingLog_HighQualityMediumSetup::duration_millis() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.duration_millis) + return _internal_duration_millis(); +} +inline void SharingLog_HighQualityMediumSetup::_internal_set_duration_millis(int64_t value) { + _has_bits_[0] |= 0x00000004u; + duration_millis_ = value; +} +inline void SharingLog_HighQualityMediumSetup::set_duration_millis(int64_t value) { + _internal_set_duration_millis(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.duration_millis) +} + +// optional bool is_timeout = 4; +inline bool SharingLog_HighQualityMediumSetup::_internal_has_is_timeout() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SharingLog_HighQualityMediumSetup::has_is_timeout() const { + return _internal_has_is_timeout(); +} +inline void SharingLog_HighQualityMediumSetup::clear_is_timeout() { + is_timeout_ = false; + _has_bits_[0] &= ~0x00000008u; +} +inline bool SharingLog_HighQualityMediumSetup::_internal_is_timeout() const { + return is_timeout_; +} +inline bool SharingLog_HighQualityMediumSetup::is_timeout() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.is_timeout) + return _internal_is_timeout(); +} +inline void SharingLog_HighQualityMediumSetup::_internal_set_is_timeout(bool value) { + _has_bits_[0] |= 0x00000008u; + is_timeout_ = value; +} +inline void SharingLog_HighQualityMediumSetup::set_is_timeout(bool value) { + _internal_set_is_timeout(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.is_timeout) +} + +// optional int32 original_quality = 5; +inline bool SharingLog_HighQualityMediumSetup::_internal_has_original_quality() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool SharingLog_HighQualityMediumSetup::has_original_quality() const { + return _internal_has_original_quality(); +} +inline void SharingLog_HighQualityMediumSetup::clear_original_quality() { + original_quality_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline int32_t SharingLog_HighQualityMediumSetup::_internal_original_quality() const { + return original_quality_; +} +inline int32_t SharingLog_HighQualityMediumSetup::original_quality() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.original_quality) + return _internal_original_quality(); +} +inline void SharingLog_HighQualityMediumSetup::_internal_set_original_quality(int32_t value) { + _has_bits_[0] |= 0x00000010u; + original_quality_ = value; +} +inline void SharingLog_HighQualityMediumSetup::set_original_quality(int32_t value) { + _internal_set_original_quality(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.original_quality) +} + +// optional int32 connection_medium = 6; +inline bool SharingLog_HighQualityMediumSetup::_internal_has_connection_medium() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool SharingLog_HighQualityMediumSetup::has_connection_medium() const { + return _internal_has_connection_medium(); +} +inline void SharingLog_HighQualityMediumSetup::clear_connection_medium() { + connection_medium_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline int32_t SharingLog_HighQualityMediumSetup::_internal_connection_medium() const { + return connection_medium_; +} +inline int32_t SharingLog_HighQualityMediumSetup::connection_medium() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.connection_medium) + return _internal_connection_medium(); +} +inline void SharingLog_HighQualityMediumSetup::_internal_set_connection_medium(int32_t value) { + _has_bits_[0] |= 0x00000020u; + connection_medium_ = value; +} +inline void SharingLog_HighQualityMediumSetup::set_connection_medium(int32_t value) { + _internal_set_connection_medium(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.connection_medium) +} + +// optional int32 connection_mode = 7; +inline bool SharingLog_HighQualityMediumSetup::_internal_has_connection_mode() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool SharingLog_HighQualityMediumSetup::has_connection_mode() const { + return _internal_has_connection_mode(); +} +inline void SharingLog_HighQualityMediumSetup::clear_connection_mode() { + connection_mode_ = 0; + _has_bits_[0] &= ~0x00000040u; +} +inline int32_t SharingLog_HighQualityMediumSetup::_internal_connection_mode() const { + return connection_mode_; +} +inline int32_t SharingLog_HighQualityMediumSetup::connection_mode() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.connection_mode) + return _internal_connection_mode(); +} +inline void SharingLog_HighQualityMediumSetup::_internal_set_connection_mode(int32_t value) { + _has_bits_[0] |= 0x00000040u; + connection_mode_ = value; +} +inline void SharingLog_HighQualityMediumSetup::set_connection_mode(int32_t value) { + _internal_set_connection_mode(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.connection_mode) +} + +// optional int32 instant_connection_result = 8; +inline bool SharingLog_HighQualityMediumSetup::_internal_has_instant_connection_result() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + return value; +} +inline bool SharingLog_HighQualityMediumSetup::has_instant_connection_result() const { + return _internal_has_instant_connection_result(); +} +inline void SharingLog_HighQualityMediumSetup::clear_instant_connection_result() { + instant_connection_result_ = 0; + _has_bits_[0] &= ~0x00000080u; +} +inline int32_t SharingLog_HighQualityMediumSetup::_internal_instant_connection_result() const { + return instant_connection_result_; +} +inline int32_t SharingLog_HighQualityMediumSetup::instant_connection_result() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.instant_connection_result) + return _internal_instant_connection_result(); +} +inline void SharingLog_HighQualityMediumSetup::_internal_set_instant_connection_result(int32_t value) { + _has_bits_[0] |= 0x00000080u; + instant_connection_result_ = value; +} +inline void SharingLog_HighQualityMediumSetup::set_instant_connection_result(int32_t value) { + _internal_set_instant_connection_result(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup.instant_connection_result) +} + +// ------------------------------------------------------------------- + +// SharingLog_RpcCallStatus + +// optional .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.RpcDirection direction = 1; +inline bool SharingLog_RpcCallStatus::_internal_has_direction() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_RpcCallStatus::has_direction() const { + return _internal_has_direction(); +} +inline void SharingLog_RpcCallStatus::clear_direction() { + direction_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection SharingLog_RpcCallStatus::_internal_direction() const { + return static_cast< ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection >(direction_); +} +inline ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection SharingLog_RpcCallStatus::direction() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.direction) + return _internal_direction(); +} +inline void SharingLog_RpcCallStatus::_internal_set_direction(::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection value) { + assert(::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + direction_ = value; +} +inline void SharingLog_RpcCallStatus::set_direction(::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection value) { + _internal_set_direction(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.direction) +} + +// optional string rpc_name = 2; +inline bool SharingLog_RpcCallStatus::_internal_has_rpc_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_RpcCallStatus::has_rpc_name() const { + return _internal_has_rpc_name(); +} +inline void SharingLog_RpcCallStatus::clear_rpc_name() { + rpc_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SharingLog_RpcCallStatus::rpc_name() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.rpc_name) + return _internal_rpc_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SharingLog_RpcCallStatus::set_rpc_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + rpc_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.rpc_name) +} +inline std::string* SharingLog_RpcCallStatus::mutable_rpc_name() { + std::string* _s = _internal_mutable_rpc_name(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.rpc_name) + return _s; +} +inline const std::string& SharingLog_RpcCallStatus::_internal_rpc_name() const { + return rpc_name_.Get(); +} +inline void SharingLog_RpcCallStatus::_internal_set_rpc_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + rpc_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SharingLog_RpcCallStatus::_internal_mutable_rpc_name() { + _has_bits_[0] |= 0x00000001u; + return rpc_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SharingLog_RpcCallStatus::release_rpc_name() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.rpc_name) + if (!_internal_has_rpc_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = rpc_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (rpc_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + rpc_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SharingLog_RpcCallStatus::set_allocated_rpc_name(std::string* rpc_name) { + if (rpc_name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + rpc_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rpc_name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (rpc_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + rpc_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.rpc_name) +} + +// optional int32 error_code = 3; +inline bool SharingLog_RpcCallStatus::_internal_has_error_code() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SharingLog_RpcCallStatus::has_error_code() const { + return _internal_has_error_code(); +} +inline void SharingLog_RpcCallStatus::clear_error_code() { + error_code_ = 0; + _has_bits_[0] &= ~0x00000004u; +} +inline int32_t SharingLog_RpcCallStatus::_internal_error_code() const { + return error_code_; +} +inline int32_t SharingLog_RpcCallStatus::error_code() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.error_code) + return _internal_error_code(); +} +inline void SharingLog_RpcCallStatus::_internal_set_error_code(int32_t value) { + _has_bits_[0] |= 0x00000004u; + error_code_ = value; +} +inline void SharingLog_RpcCallStatus::set_error_code(int32_t value) { + _internal_set_error_code(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.error_code) +} + +// optional int64 latency_millis = 4; +inline bool SharingLog_RpcCallStatus::_internal_has_latency_millis() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SharingLog_RpcCallStatus::has_latency_millis() const { + return _internal_has_latency_millis(); +} +inline void SharingLog_RpcCallStatus::clear_latency_millis() { + latency_millis_ = int64_t{0}; + _has_bits_[0] &= ~0x00000008u; +} +inline int64_t SharingLog_RpcCallStatus::_internal_latency_millis() const { + return latency_millis_; +} +inline int64_t SharingLog_RpcCallStatus::latency_millis() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.latency_millis) + return _internal_latency_millis(); +} +inline void SharingLog_RpcCallStatus::_internal_set_latency_millis(int64_t value) { + _has_bits_[0] |= 0x00000008u; + latency_millis_ = value; +} +inline void SharingLog_RpcCallStatus::set_latency_millis(int64_t value) { + _internal_set_latency_millis(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.RpcCallStatus.latency_millis) +} + +// ------------------------------------------------------------------- + +// SharingLog_StartQrCodeSession + +// ------------------------------------------------------------------- + +// SharingLog_QrCodeOpenedInWebClient + +// optional .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient.ClientPlatform client_platform = 1; +inline bool SharingLog_QrCodeOpenedInWebClient::_internal_has_client_platform() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_QrCodeOpenedInWebClient::has_client_platform() const { + return _internal_has_client_platform(); +} +inline void SharingLog_QrCodeOpenedInWebClient::clear_client_platform() { + client_platform_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::_internal_client_platform() const { + return static_cast< ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform >(client_platform_); +} +inline ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform SharingLog_QrCodeOpenedInWebClient::client_platform() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient.client_platform) + return _internal_client_platform(); +} +inline void SharingLog_QrCodeOpenedInWebClient::_internal_set_client_platform(::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform value) { + assert(::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + client_platform_ = value; +} +inline void SharingLog_QrCodeOpenedInWebClient::set_client_platform(::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform value) { + _internal_set_client_platform(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient.client_platform) +} + +// optional bool is_retry = 2; +inline bool SharingLog_QrCodeOpenedInWebClient::_internal_has_is_retry() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_QrCodeOpenedInWebClient::has_is_retry() const { + return _internal_has_is_retry(); +} +inline void SharingLog_QrCodeOpenedInWebClient::clear_is_retry() { + is_retry_ = false; + _has_bits_[0] &= ~0x00000002u; +} +inline bool SharingLog_QrCodeOpenedInWebClient::_internal_is_retry() const { + return is_retry_; +} +inline bool SharingLog_QrCodeOpenedInWebClient::is_retry() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient.is_retry) + return _internal_is_retry(); +} +inline void SharingLog_QrCodeOpenedInWebClient::_internal_set_is_retry(bool value) { + _has_bits_[0] |= 0x00000002u; + is_retry_ = value; +} +inline void SharingLog_QrCodeOpenedInWebClient::set_is_retry(bool value) { + _internal_set_is_retry(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient.is_retry) +} + +// ------------------------------------------------------------------- + +// SharingLog_HatsJointEvent + +// optional int64 flow_id = 1; +inline bool SharingLog_HatsJointEvent::_internal_has_flow_id() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_HatsJointEvent::has_flow_id() const { + return _internal_has_flow_id(); +} +inline void SharingLog_HatsJointEvent::clear_flow_id() { + flow_id_ = int64_t{0}; + _has_bits_[0] &= ~0x00000002u; +} +inline int64_t SharingLog_HatsJointEvent::_internal_flow_id() const { + return flow_id_; +} +inline int64_t SharingLog_HatsJointEvent::flow_id() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent.flow_id) + return _internal_flow_id(); +} +inline void SharingLog_HatsJointEvent::_internal_set_flow_id(int64_t value) { + _has_bits_[0] |= 0x00000002u; + flow_id_ = value; +} +inline void SharingLog_HatsJointEvent::set_flow_id(int64_t value) { + _internal_set_flow_id(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent.flow_id) +} + +// optional string hats_session_id = 2; +inline bool SharingLog_HatsJointEvent::_internal_has_hats_session_id() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_HatsJointEvent::has_hats_session_id() const { + return _internal_has_hats_session_id(); +} +inline void SharingLog_HatsJointEvent::clear_hats_session_id() { + hats_session_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SharingLog_HatsJointEvent::hats_session_id() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent.hats_session_id) + return _internal_hats_session_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SharingLog_HatsJointEvent::set_hats_session_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + hats_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent.hats_session_id) +} +inline std::string* SharingLog_HatsJointEvent::mutable_hats_session_id() { + std::string* _s = _internal_mutable_hats_session_id(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent.hats_session_id) + return _s; +} +inline const std::string& SharingLog_HatsJointEvent::_internal_hats_session_id() const { + return hats_session_id_.Get(); +} +inline void SharingLog_HatsJointEvent::_internal_set_hats_session_id(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + hats_session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SharingLog_HatsJointEvent::_internal_mutable_hats_session_id() { + _has_bits_[0] |= 0x00000001u; + return hats_session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SharingLog_HatsJointEvent::release_hats_session_id() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent.hats_session_id) + if (!_internal_has_hats_session_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = hats_session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (hats_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + hats_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SharingLog_HatsJointEvent::set_allocated_hats_session_id(std::string* hats_session_id) { + if (hats_session_id != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + hats_session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hats_session_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (hats_session_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + hats_session_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.HatsJointEvent.hats_session_id) +} + +// ------------------------------------------------------------------- + +// SharingLog_ReceivePreviews + +// optional int32 num_previews = 1; +inline bool SharingLog_ReceivePreviews::_internal_has_num_previews() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_ReceivePreviews::has_num_previews() const { + return _internal_has_num_previews(); +} +inline void SharingLog_ReceivePreviews::clear_num_previews() { + num_previews_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline int32_t SharingLog_ReceivePreviews::_internal_num_previews() const { + return num_previews_; +} +inline int32_t SharingLog_ReceivePreviews::num_previews() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews.num_previews) + return _internal_num_previews(); +} +inline void SharingLog_ReceivePreviews::_internal_set_num_previews(int32_t value) { + _has_bits_[0] |= 0x00000001u; + num_previews_ = value; +} +inline void SharingLog_ReceivePreviews::set_num_previews(int32_t value) { + _internal_set_num_previews(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.ReceivePreviews.num_previews) +} + +// ------------------------------------------------------------------- + +// SharingLog_CloudCreateSharingRequest + +// optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; +inline bool SharingLog_CloudCreateSharingRequest::_internal_has_attachments_info() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || attachments_info_ != nullptr); + return value; +} +inline bool SharingLog_CloudCreateSharingRequest::has_attachments_info() const { + return _internal_has_attachments_info(); +} +inline void SharingLog_CloudCreateSharingRequest::clear_attachments_info() { + if (attachments_info_ != nullptr) attachments_info_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& SharingLog_CloudCreateSharingRequest::_internal_attachments_info() const { + const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* p = attachments_info_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_AttachmentsInfo_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& SharingLog_CloudCreateSharingRequest::attachments_info() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest.attachments_info) + return _internal_attachments_info(); +} +inline void SharingLog_CloudCreateSharingRequest::unsafe_arena_set_allocated_attachments_info( + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(attachments_info_); + } + attachments_info_ = attachments_info; + if (attachments_info) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest.attachments_info) +} +inline ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudCreateSharingRequest::release_attachments_info() { + _has_bits_[0] &= ~0x00000001u; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* temp = attachments_info_; + attachments_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 ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudCreateSharingRequest::unsafe_arena_release_attachments_info() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest.attachments_info) + _has_bits_[0] &= ~0x00000001u; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* temp = attachments_info_; + attachments_info_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudCreateSharingRequest::_internal_mutable_attachments_info() { + _has_bits_[0] |= 0x00000001u; + if (attachments_info_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo>(GetArenaForAllocation()); + attachments_info_ = p; + } + return attachments_info_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudCreateSharingRequest::mutable_attachments_info() { + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* _msg = _internal_mutable_attachments_info(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest.attachments_info) + return _msg; +} +inline void SharingLog_CloudCreateSharingRequest::set_allocated_attachments_info(::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete attachments_info_; + } + if (attachments_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo>::GetOwningArena(attachments_info); + if (message_arena != submessage_arena) { + attachments_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, attachments_info, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + attachments_info_ = attachments_info; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest.attachments_info) +} + +// optional .location.nearby.proto.sharing.CloudCreateSharingResult result = 2; +inline bool SharingLog_CloudCreateSharingRequest::_internal_has_result() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_CloudCreateSharingRequest::has_result() const { + return _internal_has_result(); +} +inline void SharingLog_CloudCreateSharingRequest::clear_result() { + result_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::location::nearby::proto::sharing::CloudCreateSharingResult SharingLog_CloudCreateSharingRequest::_internal_result() const { + return static_cast< ::location::nearby::proto::sharing::CloudCreateSharingResult >(result_); +} +inline ::location::nearby::proto::sharing::CloudCreateSharingResult SharingLog_CloudCreateSharingRequest::result() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest.result) + return _internal_result(); +} +inline void SharingLog_CloudCreateSharingRequest::_internal_set_result(::location::nearby::proto::sharing::CloudCreateSharingResult value) { + assert(::location::nearby::proto::sharing::CloudCreateSharingResult_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + result_ = value; +} +inline void SharingLog_CloudCreateSharingRequest::set_result(::location::nearby::proto::sharing::CloudCreateSharingResult value) { + _internal_set_result(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest.result) +} + +// ------------------------------------------------------------------- + +// SharingLog_CloudRegisterReceiver + +// optional .location.nearby.proto.sharing.CloudRegisterReceiverResult result = 1; +inline bool SharingLog_CloudRegisterReceiver::_internal_has_result() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_CloudRegisterReceiver::has_result() const { + return _internal_has_result(); +} +inline void SharingLog_CloudRegisterReceiver::clear_result() { + result_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::location::nearby::proto::sharing::CloudRegisterReceiverResult SharingLog_CloudRegisterReceiver::_internal_result() const { + return static_cast< ::location::nearby::proto::sharing::CloudRegisterReceiverResult >(result_); +} +inline ::location::nearby::proto::sharing::CloudRegisterReceiverResult SharingLog_CloudRegisterReceiver::result() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver.result) + return _internal_result(); +} +inline void SharingLog_CloudRegisterReceiver::_internal_set_result(::location::nearby::proto::sharing::CloudRegisterReceiverResult value) { + assert(::location::nearby::proto::sharing::CloudRegisterReceiverResult_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + result_ = value; +} +inline void SharingLog_CloudRegisterReceiver::set_result(::location::nearby::proto::sharing::CloudRegisterReceiverResult value) { + _internal_set_result(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver.result) +} + +// ------------------------------------------------------------------- + +// SharingLog_CloudUploadStart + +// optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; +inline bool SharingLog_CloudUploadStart::_internal_has_attachments_info() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || attachments_info_ != nullptr); + return value; +} +inline bool SharingLog_CloudUploadStart::has_attachments_info() const { + return _internal_has_attachments_info(); +} +inline void SharingLog_CloudUploadStart::clear_attachments_info() { + if (attachments_info_ != nullptr) attachments_info_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& SharingLog_CloudUploadStart::_internal_attachments_info() const { + const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* p = attachments_info_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_AttachmentsInfo_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& SharingLog_CloudUploadStart::attachments_info() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart.attachments_info) + return _internal_attachments_info(); +} +inline void SharingLog_CloudUploadStart::unsafe_arena_set_allocated_attachments_info( + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(attachments_info_); + } + attachments_info_ = attachments_info; + if (attachments_info) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart.attachments_info) +} +inline ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudUploadStart::release_attachments_info() { + _has_bits_[0] &= ~0x00000001u; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* temp = attachments_info_; + attachments_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 ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudUploadStart::unsafe_arena_release_attachments_info() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart.attachments_info) + _has_bits_[0] &= ~0x00000001u; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* temp = attachments_info_; + attachments_info_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudUploadStart::_internal_mutable_attachments_info() { + _has_bits_[0] |= 0x00000001u; + if (attachments_info_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo>(GetArenaForAllocation()); + attachments_info_ = p; + } + return attachments_info_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudUploadStart::mutable_attachments_info() { + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* _msg = _internal_mutable_attachments_info(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart.attachments_info) + return _msg; +} +inline void SharingLog_CloudUploadStart::set_allocated_attachments_info(::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete attachments_info_; + } + if (attachments_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo>::GetOwningArena(attachments_info); + if (message_arena != submessage_arena) { + attachments_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, attachments_info, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + attachments_info_ = attachments_info; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart.attachments_info) +} + +// optional .location.nearby.proto.sharing.CloudActionType action_type = 2; +inline bool SharingLog_CloudUploadStart::_internal_has_action_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_CloudUploadStart::has_action_type() const { + return _internal_has_action_type(); +} +inline void SharingLog_CloudUploadStart::clear_action_type() { + action_type_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::location::nearby::proto::sharing::CloudActionType SharingLog_CloudUploadStart::_internal_action_type() const { + return static_cast< ::location::nearby::proto::sharing::CloudActionType >(action_type_); +} +inline ::location::nearby::proto::sharing::CloudActionType SharingLog_CloudUploadStart::action_type() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart.action_type) + return _internal_action_type(); +} +inline void SharingLog_CloudUploadStart::_internal_set_action_type(::location::nearby::proto::sharing::CloudActionType value) { + assert(::location::nearby::proto::sharing::CloudActionType_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + action_type_ = value; +} +inline void SharingLog_CloudUploadStart::set_action_type(::location::nearby::proto::sharing::CloudActionType value) { + _internal_set_action_type(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudUploadStart.action_type) +} + +// ------------------------------------------------------------------- + +// SharingLog_CloudUploadEnd + +// repeated .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo upload_infos = 1; +inline int SharingLog_CloudUploadEnd::_internal_upload_infos_size() const { + return upload_infos_.size(); +} +inline int SharingLog_CloudUploadEnd::upload_infos_size() const { + return _internal_upload_infos_size(); +} +inline void SharingLog_CloudUploadEnd::clear_upload_infos() { + upload_infos_.Clear(); +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* SharingLog_CloudUploadEnd::mutable_upload_infos(int index) { + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd.upload_infos) + return upload_infos_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >* +SharingLog_CloudUploadEnd::mutable_upload_infos() { + // @@protoc_insertion_point(field_mutable_list:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd.upload_infos) + return &upload_infos_; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo& SharingLog_CloudUploadEnd::_internal_upload_infos(int index) const { + return upload_infos_.Get(index); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo& SharingLog_CloudUploadEnd::upload_infos(int index) const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd.upload_infos) + return _internal_upload_infos(index); +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* SharingLog_CloudUploadEnd::_internal_add_upload_infos() { + return upload_infos_.Add(); +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* SharingLog_CloudUploadEnd::add_upload_infos() { + ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* _add = _internal_add_upload_infos(); + // @@protoc_insertion_point(field_add:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd.upload_infos) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >& +SharingLog_CloudUploadEnd::upload_infos() const { + // @@protoc_insertion_point(field_list:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd.upload_infos) + return upload_infos_; +} + +// optional .location.nearby.proto.sharing.CloudActionType action_type = 2; +inline bool SharingLog_CloudUploadEnd::_internal_has_action_type() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_CloudUploadEnd::has_action_type() const { + return _internal_has_action_type(); +} +inline void SharingLog_CloudUploadEnd::clear_action_type() { + action_type_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::location::nearby::proto::sharing::CloudActionType SharingLog_CloudUploadEnd::_internal_action_type() const { + return static_cast< ::location::nearby::proto::sharing::CloudActionType >(action_type_); +} +inline ::location::nearby::proto::sharing::CloudActionType SharingLog_CloudUploadEnd::action_type() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd.action_type) + return _internal_action_type(); +} +inline void SharingLog_CloudUploadEnd::_internal_set_action_type(::location::nearby::proto::sharing::CloudActionType value) { + assert(::location::nearby::proto::sharing::CloudActionType_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + action_type_ = value; +} +inline void SharingLog_CloudUploadEnd::set_action_type(::location::nearby::proto::sharing::CloudActionType value) { + _internal_set_action_type(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd.action_type) +} + +// ------------------------------------------------------------------- + +// SharingLog_CloudDownloadStart + +// optional .nearby.sharing.analytics.proto.SharingLog.AttachmentsInfo attachments_info = 1; +inline bool SharingLog_CloudDownloadStart::_internal_has_attachments_info() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || attachments_info_ != nullptr); + return value; +} +inline bool SharingLog_CloudDownloadStart::has_attachments_info() const { + return _internal_has_attachments_info(); +} +inline void SharingLog_CloudDownloadStart::clear_attachments_info() { + if (attachments_info_ != nullptr) attachments_info_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& SharingLog_CloudDownloadStart::_internal_attachments_info() const { + const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* p = attachments_info_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_AttachmentsInfo_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo& SharingLog_CloudDownloadStart::attachments_info() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart.attachments_info) + return _internal_attachments_info(); +} +inline void SharingLog_CloudDownloadStart::unsafe_arena_set_allocated_attachments_info( + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(attachments_info_); + } + attachments_info_ = attachments_info; + if (attachments_info) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart.attachments_info) +} +inline ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudDownloadStart::release_attachments_info() { + _has_bits_[0] &= ~0x00000001u; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* temp = attachments_info_; + attachments_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 ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudDownloadStart::unsafe_arena_release_attachments_info() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart.attachments_info) + _has_bits_[0] &= ~0x00000001u; + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* temp = attachments_info_; + attachments_info_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudDownloadStart::_internal_mutable_attachments_info() { + _has_bits_[0] |= 0x00000001u; + if (attachments_info_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo>(GetArenaForAllocation()); + attachments_info_ = p; + } + return attachments_info_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* SharingLog_CloudDownloadStart::mutable_attachments_info() { + ::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* _msg = _internal_mutable_attachments_info(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart.attachments_info) + return _msg; +} +inline void SharingLog_CloudDownloadStart::set_allocated_attachments_info(::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo* attachments_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete attachments_info_; + } + if (attachments_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_AttachmentsInfo>::GetOwningArena(attachments_info); + if (message_arena != submessage_arena) { + attachments_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, attachments_info, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + attachments_info_ = attachments_info; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart.attachments_info) +} + +// optional .location.nearby.proto.sharing.CloudActionType action_type = 2; +inline bool SharingLog_CloudDownloadStart::_internal_has_action_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_CloudDownloadStart::has_action_type() const { + return _internal_has_action_type(); +} +inline void SharingLog_CloudDownloadStart::clear_action_type() { + action_type_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline ::location::nearby::proto::sharing::CloudActionType SharingLog_CloudDownloadStart::_internal_action_type() const { + return static_cast< ::location::nearby::proto::sharing::CloudActionType >(action_type_); +} +inline ::location::nearby::proto::sharing::CloudActionType SharingLog_CloudDownloadStart::action_type() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart.action_type) + return _internal_action_type(); +} +inline void SharingLog_CloudDownloadStart::_internal_set_action_type(::location::nearby::proto::sharing::CloudActionType value) { + assert(::location::nearby::proto::sharing::CloudActionType_IsValid(value)); + _has_bits_[0] |= 0x00000002u; + action_type_ = value; +} +inline void SharingLog_CloudDownloadStart::set_action_type(::location::nearby::proto::sharing::CloudActionType value) { + _internal_set_action_type(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart.action_type) +} + +// ------------------------------------------------------------------- + +// SharingLog_CloudDownloadEnd + +// repeated .nearby.sharing.analytics.proto.SharingLog.CloudAttachmentInfo download_infos = 1; +inline int SharingLog_CloudDownloadEnd::_internal_download_infos_size() const { + return download_infos_.size(); +} +inline int SharingLog_CloudDownloadEnd::download_infos_size() const { + return _internal_download_infos_size(); +} +inline void SharingLog_CloudDownloadEnd::clear_download_infos() { + download_infos_.Clear(); +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* SharingLog_CloudDownloadEnd::mutable_download_infos(int index) { + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd.download_infos) + return download_infos_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >* +SharingLog_CloudDownloadEnd::mutable_download_infos() { + // @@protoc_insertion_point(field_mutable_list:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd.download_infos) + return &download_infos_; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo& SharingLog_CloudDownloadEnd::_internal_download_infos(int index) const { + return download_infos_.Get(index); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo& SharingLog_CloudDownloadEnd::download_infos(int index) const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd.download_infos) + return _internal_download_infos(index); +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* SharingLog_CloudDownloadEnd::_internal_add_download_infos() { + return download_infos_.Add(); +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* SharingLog_CloudDownloadEnd::add_download_infos() { + ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo* _add = _internal_add_download_infos(); + // @@protoc_insertion_point(field_add:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd.download_infos) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::nearby::sharing::analytics::proto::SharingLog_CloudAttachmentInfo >& +SharingLog_CloudDownloadEnd::download_infos() const { + // @@protoc_insertion_point(field_list:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd.download_infos) + return download_infos_; +} + +// optional .location.nearby.proto.sharing.CloudActionType action_type = 2; +inline bool SharingLog_CloudDownloadEnd::_internal_has_action_type() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_CloudDownloadEnd::has_action_type() const { + return _internal_has_action_type(); +} +inline void SharingLog_CloudDownloadEnd::clear_action_type() { + action_type_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::location::nearby::proto::sharing::CloudActionType SharingLog_CloudDownloadEnd::_internal_action_type() const { + return static_cast< ::location::nearby::proto::sharing::CloudActionType >(action_type_); +} +inline ::location::nearby::proto::sharing::CloudActionType SharingLog_CloudDownloadEnd::action_type() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd.action_type) + return _internal_action_type(); +} +inline void SharingLog_CloudDownloadEnd::_internal_set_action_type(::location::nearby::proto::sharing::CloudActionType value) { + assert(::location::nearby::proto::sharing::CloudActionType_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + action_type_ = value; +} +inline void SharingLog_CloudDownloadEnd::set_action_type(::location::nearby::proto::sharing::CloudActionType value) { + _internal_set_action_type(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd.action_type) +} + +// ------------------------------------------------------------------- + +// SharingLog_CloudSharingRpcResult + +// optional string rpc_name = 1; +inline bool SharingLog_CloudSharingRpcResult::_internal_has_rpc_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool SharingLog_CloudSharingRpcResult::has_rpc_name() const { + return _internal_has_rpc_name(); +} +inline void SharingLog_CloudSharingRpcResult::clear_rpc_name() { + rpc_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string& SharingLog_CloudSharingRpcResult::rpc_name() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.rpc_name) + return _internal_rpc_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SharingLog_CloudSharingRpcResult::set_rpc_name(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + rpc_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.rpc_name) +} +inline std::string* SharingLog_CloudSharingRpcResult::mutable_rpc_name() { + std::string* _s = _internal_mutable_rpc_name(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.rpc_name) + return _s; +} +inline const std::string& SharingLog_CloudSharingRpcResult::_internal_rpc_name() const { + return rpc_name_.Get(); +} +inline void SharingLog_CloudSharingRpcResult::_internal_set_rpc_name(const std::string& value) { + _has_bits_[0] |= 0x00000001u; + rpc_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SharingLog_CloudSharingRpcResult::_internal_mutable_rpc_name() { + _has_bits_[0] |= 0x00000001u; + return rpc_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SharingLog_CloudSharingRpcResult::release_rpc_name() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.rpc_name) + if (!_internal_has_rpc_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto* p = rpc_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (rpc_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + rpc_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SharingLog_CloudSharingRpcResult::set_allocated_rpc_name(std::string* rpc_name) { + if (rpc_name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + rpc_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rpc_name, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (rpc_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + rpc_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.rpc_name) +} + +// optional int32 status_code = 2; +inline bool SharingLog_CloudSharingRpcResult::_internal_has_status_code() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool SharingLog_CloudSharingRpcResult::has_status_code() const { + return _internal_has_status_code(); +} +inline void SharingLog_CloudSharingRpcResult::clear_status_code() { + status_code_ = 0; + _has_bits_[0] &= ~0x00000008u; +} +inline int32_t SharingLog_CloudSharingRpcResult::_internal_status_code() const { + return status_code_; +} +inline int32_t SharingLog_CloudSharingRpcResult::status_code() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.status_code) + return _internal_status_code(); +} +inline void SharingLog_CloudSharingRpcResult::_internal_set_status_code(int32_t value) { + _has_bits_[0] |= 0x00000008u; + status_code_ = value; +} +inline void SharingLog_CloudSharingRpcResult::set_status_code(int32_t value) { + _internal_set_status_code(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.status_code) +} + +// optional int64 latency_millis = 3; +inline bool SharingLog_CloudSharingRpcResult::_internal_has_latency_millis() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool SharingLog_CloudSharingRpcResult::has_latency_millis() const { + return _internal_has_latency_millis(); +} +inline void SharingLog_CloudSharingRpcResult::clear_latency_millis() { + latency_millis_ = int64_t{0}; + _has_bits_[0] &= ~0x00000004u; +} +inline int64_t SharingLog_CloudSharingRpcResult::_internal_latency_millis() const { + return latency_millis_; +} +inline int64_t SharingLog_CloudSharingRpcResult::latency_millis() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.latency_millis) + return _internal_latency_millis(); +} +inline void SharingLog_CloudSharingRpcResult::_internal_set_latency_millis(int64_t value) { + _has_bits_[0] |= 0x00000004u; + latency_millis_ = value; +} +inline void SharingLog_CloudSharingRpcResult::set_latency_millis(int64_t value) { + _internal_set_latency_millis(value); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.latency_millis) +} + +// optional string cloud_sharing_id = 4; +inline bool SharingLog_CloudSharingRpcResult::_internal_has_cloud_sharing_id() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool SharingLog_CloudSharingRpcResult::has_cloud_sharing_id() const { + return _internal_has_cloud_sharing_id(); +} +inline void SharingLog_CloudSharingRpcResult::clear_cloud_sharing_id() { + cloud_sharing_id_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string& SharingLog_CloudSharingRpcResult::cloud_sharing_id() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.cloud_sharing_id) + return _internal_cloud_sharing_id(); +} +template +inline PROTOBUF_ALWAYS_INLINE +void SharingLog_CloudSharingRpcResult::set_cloud_sharing_id(ArgT0&& arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + cloud_sharing_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.cloud_sharing_id) +} +inline std::string* SharingLog_CloudSharingRpcResult::mutable_cloud_sharing_id() { + std::string* _s = _internal_mutable_cloud_sharing_id(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.cloud_sharing_id) + return _s; +} +inline const std::string& SharingLog_CloudSharingRpcResult::_internal_cloud_sharing_id() const { + return cloud_sharing_id_.Get(); +} +inline void SharingLog_CloudSharingRpcResult::_internal_set_cloud_sharing_id(const std::string& value) { + _has_bits_[0] |= 0x00000002u; + cloud_sharing_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); +} +inline std::string* SharingLog_CloudSharingRpcResult::_internal_mutable_cloud_sharing_id() { + _has_bits_[0] |= 0x00000002u; + return cloud_sharing_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); +} +inline std::string* SharingLog_CloudSharingRpcResult::release_cloud_sharing_id() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.cloud_sharing_id) + if (!_internal_has_cloud_sharing_id()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto* p = cloud_sharing_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (cloud_sharing_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + cloud_sharing_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void SharingLog_CloudSharingRpcResult::set_allocated_cloud_sharing_id(std::string* cloud_sharing_id) { + if (cloud_sharing_id != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + cloud_sharing_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cloud_sharing_id, + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (cloud_sharing_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + cloud_sharing_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult.cloud_sharing_id) +} + +// ------------------------------------------------------------------- + // SharingLog // optional .location.nearby.proto.sharing.EventType event_type = 1; inline bool SharingLog::_internal_has_event_type() const { - bool value = (_has_bits_[2] & 0x00000080u) != 0; + bool value = (_has_bits_[2] & 0x00200000u) != 0; return value; } inline bool SharingLog::has_event_type() const { @@ -22090,7 +28785,7 @@ inline bool SharingLog::has_event_type() const { } inline void SharingLog::clear_event_type() { event_type_ = 0; - _has_bits_[2] &= ~0x00000080u; + _has_bits_[2] &= ~0x00200000u; } inline ::location::nearby::proto::sharing::EventType SharingLog::_internal_event_type() const { return static_cast< ::location::nearby::proto::sharing::EventType >(event_type_); @@ -22101,7 +28796,7 @@ inline ::location::nearby::proto::sharing::EventType SharingLog::event_type() co } inline void SharingLog::_internal_set_event_type(::location::nearby::proto::sharing::EventType value) { assert(::location::nearby::proto::sharing::EventType_IsValid(value)); - _has_bits_[2] |= 0x00000080u; + _has_bits_[2] |= 0x00200000u; event_type_ = value; } inline void SharingLog::set_event_type(::location::nearby::proto::sharing::EventType value) { @@ -24361,7 +31056,7 @@ inline void SharingLog::set_allocated_remove_contact(::nearby::sharing::analytic // optional .location.nearby.proto.sharing.LogSource log_source = 27; inline bool SharingLog::_internal_has_log_source() const { - bool value = (_has_bits_[2] & 0x00000100u) != 0; + bool value = (_has_bits_[2] & 0x00400000u) != 0; return value; } inline bool SharingLog::has_log_source() const { @@ -24369,7 +31064,7 @@ inline bool SharingLog::has_log_source() const { } inline void SharingLog::clear_log_source() { log_source_ = 0; - _has_bits_[2] &= ~0x00000100u; + _has_bits_[2] &= ~0x00400000u; } inline ::location::nearby::proto::sharing::LogSource SharingLog::_internal_log_source() const { return static_cast< ::location::nearby::proto::sharing::LogSource >(log_source_); @@ -24380,7 +31075,7 @@ inline ::location::nearby::proto::sharing::LogSource SharingLog::log_source() co } inline void SharingLog::_internal_set_log_source(::location::nearby::proto::sharing::LogSource value) { assert(::location::nearby::proto::sharing::LogSource_IsValid(value)); - _has_bits_[2] |= 0x00000100u; + _has_bits_[2] |= 0x00400000u; log_source_ = value; } inline void SharingLog::set_log_source(::location::nearby::proto::sharing::LogSource value) { @@ -24819,7 +31514,7 @@ inline void SharingLog::set_allocated_version(std::string* version) { // optional .location.nearby.proto.sharing.EventCategory event_category = 33; inline bool SharingLog::_internal_has_event_category() const { - bool value = (_has_bits_[2] & 0x00000200u) != 0; + bool value = (_has_bits_[2] & 0x00800000u) != 0; return value; } inline bool SharingLog::has_event_category() const { @@ -24827,7 +31522,7 @@ inline bool SharingLog::has_event_category() const { } inline void SharingLog::clear_event_category() { event_category_ = 0; - _has_bits_[2] &= ~0x00000200u; + _has_bits_[2] &= ~0x00800000u; } inline ::location::nearby::proto::sharing::EventCategory SharingLog::_internal_event_category() const { return static_cast< ::location::nearby::proto::sharing::EventCategory >(event_category_); @@ -24838,7 +31533,7 @@ inline ::location::nearby::proto::sharing::EventCategory SharingLog::event_categ } inline void SharingLog::_internal_set_event_category(::location::nearby::proto::sharing::EventCategory value) { assert(::location::nearby::proto::sharing::EventCategory_IsValid(value)); - _has_bits_[2] |= 0x00000200u; + _has_bits_[2] |= 0x00800000u; event_category_ = value; } inline void SharingLog::set_event_category(::location::nearby::proto::sharing::EventCategory value) { @@ -28494,6 +35189,1266 @@ inline void SharingLog::set_allocated_show_allow_permission_auto_access(::nearby // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.show_allow_permission_auto_access) } +// optional .nearby.sharing.analytics.proto.SharingLog.ShowWaitingForAccept show_waiting_for_accept = 76; +inline bool SharingLog::_internal_has_show_waiting_for_accept() const { + bool value = (_has_bits_[2] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || show_waiting_for_accept_ != nullptr); + return value; +} +inline bool SharingLog::has_show_waiting_for_accept() const { + return _internal_has_show_waiting_for_accept(); +} +inline void SharingLog::clear_show_waiting_for_accept() { + if (show_waiting_for_accept_ != nullptr) show_waiting_for_accept_->Clear(); + _has_bits_[2] &= ~0x00000080u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept& SharingLog::_internal_show_waiting_for_accept() const { + const ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* p = show_waiting_for_accept_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_ShowWaitingForAccept_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept& SharingLog::show_waiting_for_accept() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.show_waiting_for_accept) + return _internal_show_waiting_for_accept(); +} +inline void SharingLog::unsafe_arena_set_allocated_show_waiting_for_accept( + ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* show_waiting_for_accept) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(show_waiting_for_accept_); + } + show_waiting_for_accept_ = show_waiting_for_accept; + if (show_waiting_for_accept) { + _has_bits_[2] |= 0x00000080u; + } else { + _has_bits_[2] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.show_waiting_for_accept) +} +inline ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* SharingLog::release_show_waiting_for_accept() { + _has_bits_[2] &= ~0x00000080u; + ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* temp = show_waiting_for_accept_; + show_waiting_for_accept_ = 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 ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* SharingLog::unsafe_arena_release_show_waiting_for_accept() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.show_waiting_for_accept) + _has_bits_[2] &= ~0x00000080u; + ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* temp = show_waiting_for_accept_; + show_waiting_for_accept_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* SharingLog::_internal_mutable_show_waiting_for_accept() { + _has_bits_[2] |= 0x00000080u; + if (show_waiting_for_accept_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept>(GetArenaForAllocation()); + show_waiting_for_accept_ = p; + } + return show_waiting_for_accept_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* SharingLog::mutable_show_waiting_for_accept() { + ::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* _msg = _internal_mutable_show_waiting_for_accept(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.show_waiting_for_accept) + return _msg; +} +inline void SharingLog::set_allocated_show_waiting_for_accept(::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept* show_waiting_for_accept) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete show_waiting_for_accept_; + } + if (show_waiting_for_accept) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_ShowWaitingForAccept>::GetOwningArena(show_waiting_for_accept); + if (message_arena != submessage_arena) { + show_waiting_for_accept = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, show_waiting_for_accept, submessage_arena); + } + _has_bits_[2] |= 0x00000080u; + } else { + _has_bits_[2] &= ~0x00000080u; + } + show_waiting_for_accept_ = show_waiting_for_accept; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.show_waiting_for_accept) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.HighQualityMediumSetup high_quality_medium_setup = 77; +inline bool SharingLog::_internal_has_high_quality_medium_setup() const { + bool value = (_has_bits_[2] & 0x00000100u) != 0; + PROTOBUF_ASSUME(!value || high_quality_medium_setup_ != nullptr); + return value; +} +inline bool SharingLog::has_high_quality_medium_setup() const { + return _internal_has_high_quality_medium_setup(); +} +inline void SharingLog::clear_high_quality_medium_setup() { + if (high_quality_medium_setup_ != nullptr) high_quality_medium_setup_->Clear(); + _has_bits_[2] &= ~0x00000100u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup& SharingLog::_internal_high_quality_medium_setup() const { + const ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* p = high_quality_medium_setup_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_HighQualityMediumSetup_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup& SharingLog::high_quality_medium_setup() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.high_quality_medium_setup) + return _internal_high_quality_medium_setup(); +} +inline void SharingLog::unsafe_arena_set_allocated_high_quality_medium_setup( + ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* high_quality_medium_setup) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(high_quality_medium_setup_); + } + high_quality_medium_setup_ = high_quality_medium_setup; + if (high_quality_medium_setup) { + _has_bits_[2] |= 0x00000100u; + } else { + _has_bits_[2] &= ~0x00000100u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.high_quality_medium_setup) +} +inline ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* SharingLog::release_high_quality_medium_setup() { + _has_bits_[2] &= ~0x00000100u; + ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* temp = high_quality_medium_setup_; + high_quality_medium_setup_ = 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 ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* SharingLog::unsafe_arena_release_high_quality_medium_setup() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.high_quality_medium_setup) + _has_bits_[2] &= ~0x00000100u; + ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* temp = high_quality_medium_setup_; + high_quality_medium_setup_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* SharingLog::_internal_mutable_high_quality_medium_setup() { + _has_bits_[2] |= 0x00000100u; + if (high_quality_medium_setup_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup>(GetArenaForAllocation()); + high_quality_medium_setup_ = p; + } + return high_quality_medium_setup_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* SharingLog::mutable_high_quality_medium_setup() { + ::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* _msg = _internal_mutable_high_quality_medium_setup(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.high_quality_medium_setup) + return _msg; +} +inline void SharingLog::set_allocated_high_quality_medium_setup(::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup* high_quality_medium_setup) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete high_quality_medium_setup_; + } + if (high_quality_medium_setup) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_HighQualityMediumSetup>::GetOwningArena(high_quality_medium_setup); + if (message_arena != submessage_arena) { + high_quality_medium_setup = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, high_quality_medium_setup, submessage_arena); + } + _has_bits_[2] |= 0x00000100u; + } else { + _has_bits_[2] &= ~0x00000100u; + } + high_quality_medium_setup_ = high_quality_medium_setup; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.high_quality_medium_setup) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.RpcCallStatus rpc_call_status = 78; +inline bool SharingLog::_internal_has_rpc_call_status() const { + bool value = (_has_bits_[2] & 0x00000200u) != 0; + PROTOBUF_ASSUME(!value || rpc_call_status_ != nullptr); + return value; +} +inline bool SharingLog::has_rpc_call_status() const { + return _internal_has_rpc_call_status(); +} +inline void SharingLog::clear_rpc_call_status() { + if (rpc_call_status_ != nullptr) rpc_call_status_->Clear(); + _has_bits_[2] &= ~0x00000200u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus& SharingLog::_internal_rpc_call_status() const { + const ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* p = rpc_call_status_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_RpcCallStatus_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus& SharingLog::rpc_call_status() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.rpc_call_status) + return _internal_rpc_call_status(); +} +inline void SharingLog::unsafe_arena_set_allocated_rpc_call_status( + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* rpc_call_status) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rpc_call_status_); + } + rpc_call_status_ = rpc_call_status; + if (rpc_call_status) { + _has_bits_[2] |= 0x00000200u; + } else { + _has_bits_[2] &= ~0x00000200u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.rpc_call_status) +} +inline ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* SharingLog::release_rpc_call_status() { + _has_bits_[2] &= ~0x00000200u; + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* temp = rpc_call_status_; + rpc_call_status_ = 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 ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* SharingLog::unsafe_arena_release_rpc_call_status() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.rpc_call_status) + _has_bits_[2] &= ~0x00000200u; + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* temp = rpc_call_status_; + rpc_call_status_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* SharingLog::_internal_mutable_rpc_call_status() { + _has_bits_[2] |= 0x00000200u; + if (rpc_call_status_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus>(GetArenaForAllocation()); + rpc_call_status_ = p; + } + return rpc_call_status_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* SharingLog::mutable_rpc_call_status() { + ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* _msg = _internal_mutable_rpc_call_status(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.rpc_call_status) + return _msg; +} +inline void SharingLog::set_allocated_rpc_call_status(::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus* rpc_call_status) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete rpc_call_status_; + } + if (rpc_call_status) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus>::GetOwningArena(rpc_call_status); + if (message_arena != submessage_arena) { + rpc_call_status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, rpc_call_status, submessage_arena); + } + _has_bits_[2] |= 0x00000200u; + } else { + _has_bits_[2] &= ~0x00000200u; + } + rpc_call_status_ = rpc_call_status; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.rpc_call_status) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.StartQrCodeSession start_qr_code_session = 79; +inline bool SharingLog::_internal_has_start_qr_code_session() const { + bool value = (_has_bits_[2] & 0x00000400u) != 0; + PROTOBUF_ASSUME(!value || start_qr_code_session_ != nullptr); + return value; +} +inline bool SharingLog::has_start_qr_code_session() const { + return _internal_has_start_qr_code_session(); +} +inline void SharingLog::clear_start_qr_code_session() { + if (start_qr_code_session_ != nullptr) start_qr_code_session_->Clear(); + _has_bits_[2] &= ~0x00000400u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession& SharingLog::_internal_start_qr_code_session() const { + const ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* p = start_qr_code_session_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_StartQrCodeSession_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession& SharingLog::start_qr_code_session() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.start_qr_code_session) + return _internal_start_qr_code_session(); +} +inline void SharingLog::unsafe_arena_set_allocated_start_qr_code_session( + ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* start_qr_code_session) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start_qr_code_session_); + } + start_qr_code_session_ = start_qr_code_session; + if (start_qr_code_session) { + _has_bits_[2] |= 0x00000400u; + } else { + _has_bits_[2] &= ~0x00000400u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.start_qr_code_session) +} +inline ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* SharingLog::release_start_qr_code_session() { + _has_bits_[2] &= ~0x00000400u; + ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* temp = start_qr_code_session_; + start_qr_code_session_ = 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 ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* SharingLog::unsafe_arena_release_start_qr_code_session() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.start_qr_code_session) + _has_bits_[2] &= ~0x00000400u; + ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* temp = start_qr_code_session_; + start_qr_code_session_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* SharingLog::_internal_mutable_start_qr_code_session() { + _has_bits_[2] |= 0x00000400u; + if (start_qr_code_session_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession>(GetArenaForAllocation()); + start_qr_code_session_ = p; + } + return start_qr_code_session_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* SharingLog::mutable_start_qr_code_session() { + ::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* _msg = _internal_mutable_start_qr_code_session(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.start_qr_code_session) + return _msg; +} +inline void SharingLog::set_allocated_start_qr_code_session(::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession* start_qr_code_session) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete start_qr_code_session_; + } + if (start_qr_code_session) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_StartQrCodeSession>::GetOwningArena(start_qr_code_session); + if (message_arena != submessage_arena) { + start_qr_code_session = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, start_qr_code_session, submessage_arena); + } + _has_bits_[2] |= 0x00000400u; + } else { + _has_bits_[2] &= ~0x00000400u; + } + start_qr_code_session_ = start_qr_code_session; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.start_qr_code_session) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.QrCodeOpenedInWebClient qr_code_opened_in_web_client = 80; +inline bool SharingLog::_internal_has_qr_code_opened_in_web_client() const { + bool value = (_has_bits_[2] & 0x00000800u) != 0; + PROTOBUF_ASSUME(!value || qr_code_opened_in_web_client_ != nullptr); + return value; +} +inline bool SharingLog::has_qr_code_opened_in_web_client() const { + return _internal_has_qr_code_opened_in_web_client(); +} +inline void SharingLog::clear_qr_code_opened_in_web_client() { + if (qr_code_opened_in_web_client_ != nullptr) qr_code_opened_in_web_client_->Clear(); + _has_bits_[2] &= ~0x00000800u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient& SharingLog::_internal_qr_code_opened_in_web_client() const { + const ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* p = qr_code_opened_in_web_client_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_QrCodeOpenedInWebClient_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient& SharingLog::qr_code_opened_in_web_client() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.qr_code_opened_in_web_client) + return _internal_qr_code_opened_in_web_client(); +} +inline void SharingLog::unsafe_arena_set_allocated_qr_code_opened_in_web_client( + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* qr_code_opened_in_web_client) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(qr_code_opened_in_web_client_); + } + qr_code_opened_in_web_client_ = qr_code_opened_in_web_client; + if (qr_code_opened_in_web_client) { + _has_bits_[2] |= 0x00000800u; + } else { + _has_bits_[2] &= ~0x00000800u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.qr_code_opened_in_web_client) +} +inline ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* SharingLog::release_qr_code_opened_in_web_client() { + _has_bits_[2] &= ~0x00000800u; + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* temp = qr_code_opened_in_web_client_; + qr_code_opened_in_web_client_ = 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 ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* SharingLog::unsafe_arena_release_qr_code_opened_in_web_client() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.qr_code_opened_in_web_client) + _has_bits_[2] &= ~0x00000800u; + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* temp = qr_code_opened_in_web_client_; + qr_code_opened_in_web_client_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* SharingLog::_internal_mutable_qr_code_opened_in_web_client() { + _has_bits_[2] |= 0x00000800u; + if (qr_code_opened_in_web_client_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient>(GetArenaForAllocation()); + qr_code_opened_in_web_client_ = p; + } + return qr_code_opened_in_web_client_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* SharingLog::mutable_qr_code_opened_in_web_client() { + ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* _msg = _internal_mutable_qr_code_opened_in_web_client(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.qr_code_opened_in_web_client) + return _msg; +} +inline void SharingLog::set_allocated_qr_code_opened_in_web_client(::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient* qr_code_opened_in_web_client) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete qr_code_opened_in_web_client_; + } + if (qr_code_opened_in_web_client) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient>::GetOwningArena(qr_code_opened_in_web_client); + if (message_arena != submessage_arena) { + qr_code_opened_in_web_client = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, qr_code_opened_in_web_client, submessage_arena); + } + _has_bits_[2] |= 0x00000800u; + } else { + _has_bits_[2] &= ~0x00000800u; + } + qr_code_opened_in_web_client_ = qr_code_opened_in_web_client; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.qr_code_opened_in_web_client) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.HatsJointEvent hats_joint_event = 81; +inline bool SharingLog::_internal_has_hats_joint_event() const { + bool value = (_has_bits_[2] & 0x00001000u) != 0; + PROTOBUF_ASSUME(!value || hats_joint_event_ != nullptr); + return value; +} +inline bool SharingLog::has_hats_joint_event() const { + return _internal_has_hats_joint_event(); +} +inline void SharingLog::clear_hats_joint_event() { + if (hats_joint_event_ != nullptr) hats_joint_event_->Clear(); + _has_bits_[2] &= ~0x00001000u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent& SharingLog::_internal_hats_joint_event() const { + const ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* p = hats_joint_event_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_HatsJointEvent_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent& SharingLog::hats_joint_event() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.hats_joint_event) + return _internal_hats_joint_event(); +} +inline void SharingLog::unsafe_arena_set_allocated_hats_joint_event( + ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* hats_joint_event) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hats_joint_event_); + } + hats_joint_event_ = hats_joint_event; + if (hats_joint_event) { + _has_bits_[2] |= 0x00001000u; + } else { + _has_bits_[2] &= ~0x00001000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.hats_joint_event) +} +inline ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* SharingLog::release_hats_joint_event() { + _has_bits_[2] &= ~0x00001000u; + ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* temp = hats_joint_event_; + hats_joint_event_ = 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 ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* SharingLog::unsafe_arena_release_hats_joint_event() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.hats_joint_event) + _has_bits_[2] &= ~0x00001000u; + ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* temp = hats_joint_event_; + hats_joint_event_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* SharingLog::_internal_mutable_hats_joint_event() { + _has_bits_[2] |= 0x00001000u; + if (hats_joint_event_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent>(GetArenaForAllocation()); + hats_joint_event_ = p; + } + return hats_joint_event_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* SharingLog::mutable_hats_joint_event() { + ::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* _msg = _internal_mutable_hats_joint_event(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.hats_joint_event) + return _msg; +} +inline void SharingLog::set_allocated_hats_joint_event(::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent* hats_joint_event) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete hats_joint_event_; + } + if (hats_joint_event) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_HatsJointEvent>::GetOwningArena(hats_joint_event); + if (message_arena != submessage_arena) { + hats_joint_event = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hats_joint_event, submessage_arena); + } + _has_bits_[2] |= 0x00001000u; + } else { + _has_bits_[2] &= ~0x00001000u; + } + hats_joint_event_ = hats_joint_event; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.hats_joint_event) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.ReceivePreviews receive_previews = 82; +inline bool SharingLog::_internal_has_receive_previews() const { + bool value = (_has_bits_[2] & 0x00002000u) != 0; + PROTOBUF_ASSUME(!value || receive_previews_ != nullptr); + return value; +} +inline bool SharingLog::has_receive_previews() const { + return _internal_has_receive_previews(); +} +inline void SharingLog::clear_receive_previews() { + if (receive_previews_ != nullptr) receive_previews_->Clear(); + _has_bits_[2] &= ~0x00002000u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews& SharingLog::_internal_receive_previews() const { + const ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* p = receive_previews_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_ReceivePreviews_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews& SharingLog::receive_previews() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.receive_previews) + return _internal_receive_previews(); +} +inline void SharingLog::unsafe_arena_set_allocated_receive_previews( + ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* receive_previews) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(receive_previews_); + } + receive_previews_ = receive_previews; + if (receive_previews) { + _has_bits_[2] |= 0x00002000u; + } else { + _has_bits_[2] &= ~0x00002000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.receive_previews) +} +inline ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* SharingLog::release_receive_previews() { + _has_bits_[2] &= ~0x00002000u; + ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* temp = receive_previews_; + receive_previews_ = 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 ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* SharingLog::unsafe_arena_release_receive_previews() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.receive_previews) + _has_bits_[2] &= ~0x00002000u; + ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* temp = receive_previews_; + receive_previews_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* SharingLog::_internal_mutable_receive_previews() { + _has_bits_[2] |= 0x00002000u; + if (receive_previews_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews>(GetArenaForAllocation()); + receive_previews_ = p; + } + return receive_previews_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* SharingLog::mutable_receive_previews() { + ::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* _msg = _internal_mutable_receive_previews(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.receive_previews) + return _msg; +} +inline void SharingLog::set_allocated_receive_previews(::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews* receive_previews) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete receive_previews_; + } + if (receive_previews) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_ReceivePreviews>::GetOwningArena(receive_previews); + if (message_arena != submessage_arena) { + receive_previews = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, receive_previews, submessage_arena); + } + _has_bits_[2] |= 0x00002000u; + } else { + _has_bits_[2] &= ~0x00002000u; + } + receive_previews_ = receive_previews; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.receive_previews) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.CloudCreateSharingRequest cloud_create_sharing_request = 83; +inline bool SharingLog::_internal_has_cloud_create_sharing_request() const { + bool value = (_has_bits_[2] & 0x00004000u) != 0; + PROTOBUF_ASSUME(!value || cloud_create_sharing_request_ != nullptr); + return value; +} +inline bool SharingLog::has_cloud_create_sharing_request() const { + return _internal_has_cloud_create_sharing_request(); +} +inline void SharingLog::clear_cloud_create_sharing_request() { + if (cloud_create_sharing_request_ != nullptr) cloud_create_sharing_request_->Clear(); + _has_bits_[2] &= ~0x00004000u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest& SharingLog::_internal_cloud_create_sharing_request() const { + const ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* p = cloud_create_sharing_request_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_CloudCreateSharingRequest_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest& SharingLog::cloud_create_sharing_request() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.cloud_create_sharing_request) + return _internal_cloud_create_sharing_request(); +} +inline void SharingLog::unsafe_arena_set_allocated_cloud_create_sharing_request( + ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* cloud_create_sharing_request) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cloud_create_sharing_request_); + } + cloud_create_sharing_request_ = cloud_create_sharing_request; + if (cloud_create_sharing_request) { + _has_bits_[2] |= 0x00004000u; + } else { + _has_bits_[2] &= ~0x00004000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_create_sharing_request) +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* SharingLog::release_cloud_create_sharing_request() { + _has_bits_[2] &= ~0x00004000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* temp = cloud_create_sharing_request_; + cloud_create_sharing_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 ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* SharingLog::unsafe_arena_release_cloud_create_sharing_request() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.cloud_create_sharing_request) + _has_bits_[2] &= ~0x00004000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* temp = cloud_create_sharing_request_; + cloud_create_sharing_request_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* SharingLog::_internal_mutable_cloud_create_sharing_request() { + _has_bits_[2] |= 0x00004000u; + if (cloud_create_sharing_request_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest>(GetArenaForAllocation()); + cloud_create_sharing_request_ = p; + } + return cloud_create_sharing_request_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* SharingLog::mutable_cloud_create_sharing_request() { + ::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* _msg = _internal_mutable_cloud_create_sharing_request(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.cloud_create_sharing_request) + return _msg; +} +inline void SharingLog::set_allocated_cloud_create_sharing_request(::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest* cloud_create_sharing_request) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete cloud_create_sharing_request_; + } + if (cloud_create_sharing_request) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_CloudCreateSharingRequest>::GetOwningArena(cloud_create_sharing_request); + if (message_arena != submessage_arena) { + cloud_create_sharing_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cloud_create_sharing_request, submessage_arena); + } + _has_bits_[2] |= 0x00004000u; + } else { + _has_bits_[2] &= ~0x00004000u; + } + cloud_create_sharing_request_ = cloud_create_sharing_request; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_create_sharing_request) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.CloudRegisterReceiver cloud_register_receiver = 84; +inline bool SharingLog::_internal_has_cloud_register_receiver() const { + bool value = (_has_bits_[2] & 0x00008000u) != 0; + PROTOBUF_ASSUME(!value || cloud_register_receiver_ != nullptr); + return value; +} +inline bool SharingLog::has_cloud_register_receiver() const { + return _internal_has_cloud_register_receiver(); +} +inline void SharingLog::clear_cloud_register_receiver() { + if (cloud_register_receiver_ != nullptr) cloud_register_receiver_->Clear(); + _has_bits_[2] &= ~0x00008000u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver& SharingLog::_internal_cloud_register_receiver() const { + const ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* p = cloud_register_receiver_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_CloudRegisterReceiver_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver& SharingLog::cloud_register_receiver() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.cloud_register_receiver) + return _internal_cloud_register_receiver(); +} +inline void SharingLog::unsafe_arena_set_allocated_cloud_register_receiver( + ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* cloud_register_receiver) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cloud_register_receiver_); + } + cloud_register_receiver_ = cloud_register_receiver; + if (cloud_register_receiver) { + _has_bits_[2] |= 0x00008000u; + } else { + _has_bits_[2] &= ~0x00008000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_register_receiver) +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* SharingLog::release_cloud_register_receiver() { + _has_bits_[2] &= ~0x00008000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* temp = cloud_register_receiver_; + cloud_register_receiver_ = 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 ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* SharingLog::unsafe_arena_release_cloud_register_receiver() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.cloud_register_receiver) + _has_bits_[2] &= ~0x00008000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* temp = cloud_register_receiver_; + cloud_register_receiver_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* SharingLog::_internal_mutable_cloud_register_receiver() { + _has_bits_[2] |= 0x00008000u; + if (cloud_register_receiver_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver>(GetArenaForAllocation()); + cloud_register_receiver_ = p; + } + return cloud_register_receiver_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* SharingLog::mutable_cloud_register_receiver() { + ::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* _msg = _internal_mutable_cloud_register_receiver(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.cloud_register_receiver) + return _msg; +} +inline void SharingLog::set_allocated_cloud_register_receiver(::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver* cloud_register_receiver) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete cloud_register_receiver_; + } + if (cloud_register_receiver) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_CloudRegisterReceiver>::GetOwningArena(cloud_register_receiver); + if (message_arena != submessage_arena) { + cloud_register_receiver = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cloud_register_receiver, submessage_arena); + } + _has_bits_[2] |= 0x00008000u; + } else { + _has_bits_[2] &= ~0x00008000u; + } + cloud_register_receiver_ = cloud_register_receiver; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_register_receiver) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadStart cloud_upload_start = 85; +inline bool SharingLog::_internal_has_cloud_upload_start() const { + bool value = (_has_bits_[2] & 0x00010000u) != 0; + PROTOBUF_ASSUME(!value || cloud_upload_start_ != nullptr); + return value; +} +inline bool SharingLog::has_cloud_upload_start() const { + return _internal_has_cloud_upload_start(); +} +inline void SharingLog::clear_cloud_upload_start() { + if (cloud_upload_start_ != nullptr) cloud_upload_start_->Clear(); + _has_bits_[2] &= ~0x00010000u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart& SharingLog::_internal_cloud_upload_start() const { + const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* p = cloud_upload_start_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_CloudUploadStart_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart& SharingLog::cloud_upload_start() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.cloud_upload_start) + return _internal_cloud_upload_start(); +} +inline void SharingLog::unsafe_arena_set_allocated_cloud_upload_start( + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* cloud_upload_start) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cloud_upload_start_); + } + cloud_upload_start_ = cloud_upload_start; + if (cloud_upload_start) { + _has_bits_[2] |= 0x00010000u; + } else { + _has_bits_[2] &= ~0x00010000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_upload_start) +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* SharingLog::release_cloud_upload_start() { + _has_bits_[2] &= ~0x00010000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* temp = cloud_upload_start_; + cloud_upload_start_ = 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 ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* SharingLog::unsafe_arena_release_cloud_upload_start() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.cloud_upload_start) + _has_bits_[2] &= ~0x00010000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* temp = cloud_upload_start_; + cloud_upload_start_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* SharingLog::_internal_mutable_cloud_upload_start() { + _has_bits_[2] |= 0x00010000u; + if (cloud_upload_start_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart>(GetArenaForAllocation()); + cloud_upload_start_ = p; + } + return cloud_upload_start_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* SharingLog::mutable_cloud_upload_start() { + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* _msg = _internal_mutable_cloud_upload_start(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.cloud_upload_start) + return _msg; +} +inline void SharingLog::set_allocated_cloud_upload_start(::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart* cloud_upload_start) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete cloud_upload_start_; + } + if (cloud_upload_start) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_CloudUploadStart>::GetOwningArena(cloud_upload_start); + if (message_arena != submessage_arena) { + cloud_upload_start = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cloud_upload_start, submessage_arena); + } + _has_bits_[2] |= 0x00010000u; + } else { + _has_bits_[2] &= ~0x00010000u; + } + cloud_upload_start_ = cloud_upload_start; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_upload_start) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.CloudUploadEnd cloud_upload_end = 86; +inline bool SharingLog::_internal_has_cloud_upload_end() const { + bool value = (_has_bits_[2] & 0x00020000u) != 0; + PROTOBUF_ASSUME(!value || cloud_upload_end_ != nullptr); + return value; +} +inline bool SharingLog::has_cloud_upload_end() const { + return _internal_has_cloud_upload_end(); +} +inline void SharingLog::clear_cloud_upload_end() { + if (cloud_upload_end_ != nullptr) cloud_upload_end_->Clear(); + _has_bits_[2] &= ~0x00020000u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd& SharingLog::_internal_cloud_upload_end() const { + const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* p = cloud_upload_end_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_CloudUploadEnd_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd& SharingLog::cloud_upload_end() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.cloud_upload_end) + return _internal_cloud_upload_end(); +} +inline void SharingLog::unsafe_arena_set_allocated_cloud_upload_end( + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* cloud_upload_end) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cloud_upload_end_); + } + cloud_upload_end_ = cloud_upload_end; + if (cloud_upload_end) { + _has_bits_[2] |= 0x00020000u; + } else { + _has_bits_[2] &= ~0x00020000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_upload_end) +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* SharingLog::release_cloud_upload_end() { + _has_bits_[2] &= ~0x00020000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* temp = cloud_upload_end_; + cloud_upload_end_ = 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 ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* SharingLog::unsafe_arena_release_cloud_upload_end() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.cloud_upload_end) + _has_bits_[2] &= ~0x00020000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* temp = cloud_upload_end_; + cloud_upload_end_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* SharingLog::_internal_mutable_cloud_upload_end() { + _has_bits_[2] |= 0x00020000u; + if (cloud_upload_end_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd>(GetArenaForAllocation()); + cloud_upload_end_ = p; + } + return cloud_upload_end_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* SharingLog::mutable_cloud_upload_end() { + ::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* _msg = _internal_mutable_cloud_upload_end(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.cloud_upload_end) + return _msg; +} +inline void SharingLog::set_allocated_cloud_upload_end(::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd* cloud_upload_end) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete cloud_upload_end_; + } + if (cloud_upload_end) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_CloudUploadEnd>::GetOwningArena(cloud_upload_end); + if (message_arena != submessage_arena) { + cloud_upload_end = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cloud_upload_end, submessage_arena); + } + _has_bits_[2] |= 0x00020000u; + } else { + _has_bits_[2] &= ~0x00020000u; + } + cloud_upload_end_ = cloud_upload_end; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_upload_end) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadStart cloud_download_start = 87; +inline bool SharingLog::_internal_has_cloud_download_start() const { + bool value = (_has_bits_[2] & 0x00040000u) != 0; + PROTOBUF_ASSUME(!value || cloud_download_start_ != nullptr); + return value; +} +inline bool SharingLog::has_cloud_download_start() const { + return _internal_has_cloud_download_start(); +} +inline void SharingLog::clear_cloud_download_start() { + if (cloud_download_start_ != nullptr) cloud_download_start_->Clear(); + _has_bits_[2] &= ~0x00040000u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart& SharingLog::_internal_cloud_download_start() const { + const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* p = cloud_download_start_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_CloudDownloadStart_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart& SharingLog::cloud_download_start() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.cloud_download_start) + return _internal_cloud_download_start(); +} +inline void SharingLog::unsafe_arena_set_allocated_cloud_download_start( + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* cloud_download_start) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cloud_download_start_); + } + cloud_download_start_ = cloud_download_start; + if (cloud_download_start) { + _has_bits_[2] |= 0x00040000u; + } else { + _has_bits_[2] &= ~0x00040000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_download_start) +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* SharingLog::release_cloud_download_start() { + _has_bits_[2] &= ~0x00040000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* temp = cloud_download_start_; + cloud_download_start_ = 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 ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* SharingLog::unsafe_arena_release_cloud_download_start() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.cloud_download_start) + _has_bits_[2] &= ~0x00040000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* temp = cloud_download_start_; + cloud_download_start_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* SharingLog::_internal_mutable_cloud_download_start() { + _has_bits_[2] |= 0x00040000u; + if (cloud_download_start_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart>(GetArenaForAllocation()); + cloud_download_start_ = p; + } + return cloud_download_start_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* SharingLog::mutable_cloud_download_start() { + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* _msg = _internal_mutable_cloud_download_start(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.cloud_download_start) + return _msg; +} +inline void SharingLog::set_allocated_cloud_download_start(::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart* cloud_download_start) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete cloud_download_start_; + } + if (cloud_download_start) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_CloudDownloadStart>::GetOwningArena(cloud_download_start); + if (message_arena != submessage_arena) { + cloud_download_start = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cloud_download_start, submessage_arena); + } + _has_bits_[2] |= 0x00040000u; + } else { + _has_bits_[2] &= ~0x00040000u; + } + cloud_download_start_ = cloud_download_start; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_download_start) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.CloudDownloadEnd cloud_download_end = 88; +inline bool SharingLog::_internal_has_cloud_download_end() const { + bool value = (_has_bits_[2] & 0x00080000u) != 0; + PROTOBUF_ASSUME(!value || cloud_download_end_ != nullptr); + return value; +} +inline bool SharingLog::has_cloud_download_end() const { + return _internal_has_cloud_download_end(); +} +inline void SharingLog::clear_cloud_download_end() { + if (cloud_download_end_ != nullptr) cloud_download_end_->Clear(); + _has_bits_[2] &= ~0x00080000u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd& SharingLog::_internal_cloud_download_end() const { + const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* p = cloud_download_end_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_CloudDownloadEnd_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd& SharingLog::cloud_download_end() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.cloud_download_end) + return _internal_cloud_download_end(); +} +inline void SharingLog::unsafe_arena_set_allocated_cloud_download_end( + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* cloud_download_end) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cloud_download_end_); + } + cloud_download_end_ = cloud_download_end; + if (cloud_download_end) { + _has_bits_[2] |= 0x00080000u; + } else { + _has_bits_[2] &= ~0x00080000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_download_end) +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* SharingLog::release_cloud_download_end() { + _has_bits_[2] &= ~0x00080000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* temp = cloud_download_end_; + cloud_download_end_ = 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 ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* SharingLog::unsafe_arena_release_cloud_download_end() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.cloud_download_end) + _has_bits_[2] &= ~0x00080000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* temp = cloud_download_end_; + cloud_download_end_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* SharingLog::_internal_mutable_cloud_download_end() { + _has_bits_[2] |= 0x00080000u; + if (cloud_download_end_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd>(GetArenaForAllocation()); + cloud_download_end_ = p; + } + return cloud_download_end_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* SharingLog::mutable_cloud_download_end() { + ::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* _msg = _internal_mutable_cloud_download_end(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.cloud_download_end) + return _msg; +} +inline void SharingLog::set_allocated_cloud_download_end(::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd* cloud_download_end) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete cloud_download_end_; + } + if (cloud_download_end) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_CloudDownloadEnd>::GetOwningArena(cloud_download_end); + if (message_arena != submessage_arena) { + cloud_download_end = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cloud_download_end, submessage_arena); + } + _has_bits_[2] |= 0x00080000u; + } else { + _has_bits_[2] &= ~0x00080000u; + } + cloud_download_end_ = cloud_download_end; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_download_end) +} + +// optional .nearby.sharing.analytics.proto.SharingLog.CloudSharingRpcResult cloud_sharing_rpc_result = 89; +inline bool SharingLog::_internal_has_cloud_sharing_rpc_result() const { + bool value = (_has_bits_[2] & 0x00100000u) != 0; + PROTOBUF_ASSUME(!value || cloud_sharing_rpc_result_ != nullptr); + return value; +} +inline bool SharingLog::has_cloud_sharing_rpc_result() const { + return _internal_has_cloud_sharing_rpc_result(); +} +inline void SharingLog::clear_cloud_sharing_rpc_result() { + if (cloud_sharing_rpc_result_ != nullptr) cloud_sharing_rpc_result_->Clear(); + _has_bits_[2] &= ~0x00100000u; +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult& SharingLog::_internal_cloud_sharing_rpc_result() const { + const ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* p = cloud_sharing_rpc_result_; + return p != nullptr ? *p : reinterpret_cast( + ::nearby::sharing::analytics::proto::_SharingLog_CloudSharingRpcResult_default_instance_); +} +inline const ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult& SharingLog::cloud_sharing_rpc_result() const { + // @@protoc_insertion_point(field_get:nearby.sharing.analytics.proto.SharingLog.cloud_sharing_rpc_result) + return _internal_cloud_sharing_rpc_result(); +} +inline void SharingLog::unsafe_arena_set_allocated_cloud_sharing_rpc_result( + ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* cloud_sharing_rpc_result) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cloud_sharing_rpc_result_); + } + cloud_sharing_rpc_result_ = cloud_sharing_rpc_result; + if (cloud_sharing_rpc_result) { + _has_bits_[2] |= 0x00100000u; + } else { + _has_bits_[2] &= ~0x00100000u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_sharing_rpc_result) +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* SharingLog::release_cloud_sharing_rpc_result() { + _has_bits_[2] &= ~0x00100000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* temp = cloud_sharing_rpc_result_; + cloud_sharing_rpc_result_ = 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 ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* SharingLog::unsafe_arena_release_cloud_sharing_rpc_result() { + // @@protoc_insertion_point(field_release:nearby.sharing.analytics.proto.SharingLog.cloud_sharing_rpc_result) + _has_bits_[2] &= ~0x00100000u; + ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* temp = cloud_sharing_rpc_result_; + cloud_sharing_rpc_result_ = nullptr; + return temp; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* SharingLog::_internal_mutable_cloud_sharing_rpc_result() { + _has_bits_[2] |= 0x00100000u; + if (cloud_sharing_rpc_result_ == nullptr) { + auto* p = CreateMaybeMessage<::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult>(GetArenaForAllocation()); + cloud_sharing_rpc_result_ = p; + } + return cloud_sharing_rpc_result_; +} +inline ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* SharingLog::mutable_cloud_sharing_rpc_result() { + ::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* _msg = _internal_mutable_cloud_sharing_rpc_result(); + // @@protoc_insertion_point(field_mutable:nearby.sharing.analytics.proto.SharingLog.cloud_sharing_rpc_result) + return _msg; +} +inline void SharingLog::set_allocated_cloud_sharing_rpc_result(::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult* cloud_sharing_rpc_result) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete cloud_sharing_rpc_result_; + } + if (cloud_sharing_rpc_result) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::nearby::sharing::analytics::proto::SharingLog_CloudSharingRpcResult>::GetOwningArena(cloud_sharing_rpc_result); + if (message_arena != submessage_arena) { + cloud_sharing_rpc_result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cloud_sharing_rpc_result, submessage_arena); + } + _has_bits_[2] |= 0x00100000u; + } else { + _has_bits_[2] &= ~0x00100000u; + } + cloud_sharing_rpc_result_ = cloud_sharing_rpc_result; + // @@protoc_insertion_point(field_set_allocated:nearby.sharing.analytics.proto.SharingLog.cloud_sharing_rpc_result) +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -28649,6 +36604,36 @@ inline void SharingLog::set_allocated_show_allow_permission_auto_access(::nearby // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) @@ -28661,6 +36646,8 @@ PROTOBUF_NAMESPACE_OPEN template <> struct is_proto_enum< ::nearby::sharing::analytics::proto::SharingLog_TextAttachment_Type> : ::std::true_type {}; template <> struct is_proto_enum< ::nearby::sharing::analytics::proto::SharingLog_FileAttachment_Type> : ::std::true_type {}; +template <> struct is_proto_enum< ::nearby::sharing::analytics::proto::SharingLog_RpcCallStatus_RpcDirection> : ::std::true_type {}; +template <> struct is_proto_enum< ::nearby::sharing::analytics::proto::SharingLog_QrCodeOpenedInWebClient_ClientPlatform> : ::std::true_type {}; PROTOBUF_NAMESPACE_CLOSE diff --git a/gen_proto.sh b/gen_proto.sh index 09a33ed5..0cb7500d 100755 --- a/gen_proto.sh +++ b/gen_proto.sh @@ -16,8 +16,8 @@ COMPILED_PROTO_PATH="compiled_proto" +${PROTOC} --cpp_out=${COMPILED_PROTO_PATH} connections/implementation/proto/offline_wire_formats.proto ${PROTOC} --cpp_out=${COMPILED_PROTO_PATH} internal/proto/analytics/connections_log.proto -${PROTOC} --cpp_out=${COMPILED_PROTO_PATH} internal/proto/analytics/fast_pair_log.proto ${PROTOC} --cpp_out=${COMPILED_PROTO_PATH} sharing/proto/analytics/nearby_sharing_log.proto -${PROTOC} --cpp_out=${COMPILED_PROTO_PATH} proto/fast_pair_enums.proto +${PROTOC} --cpp_out=${COMPILED_PROTO_PATH} proto/connections_enums.proto ${PROTOC} --cpp_out=${COMPILED_PROTO_PATH} proto/sharing_enums.proto