TySS-Dev/nearby
1
0
Fork 0
mirror of https://github.com/kidfromjupiter/nearby.git synced 2026-09-14 14:46:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

Update compiled_proto

Browse Source
This commit is contained in:
Anay Wadhera
2024-01-04 22:35:59 -08:00
parent 94ae577069
commit 733a483ee2
6 changed files with 1799 additions and 575 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc
+434 -30
View File
@@ -43,6 +43,7 @@ constexpr V1Frame::V1Frame(
, authentication_result_(nullptr)
, auto_resume_(nullptr)
, auto_reconnect_(nullptr)
, bandwidth_upgrade_retry_(nullptr)
, type_(0)
{}
struct V1FrameDefaultTypeInternal {
@@ -306,6 +307,19 @@ struct BandwidthUpgradeNegotiationFrameDefaultTypeInternal {
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeNegotiationFrameDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_default_instance_;
constexpr BandwidthUpgradeRetryFrame::BandwidthUpgradeRetryFrame(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: supported_medium_()
, is_request_(false){}
struct BandwidthUpgradeRetryFrameDefaultTypeInternal {
constexpr BandwidthUpgradeRetryFrameDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~BandwidthUpgradeRetryFrameDefaultTypeInternal() {}
union {
BandwidthUpgradeRetryFrame _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT BandwidthUpgradeRetryFrameDefaultTypeInternal _BandwidthUpgradeRetryFrame_default_instance_;
constexpr KeepAliveFrame::KeepAliveFrame(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: ack_(false)
@@ -642,13 +656,14 @@ bool V1Frame_FrameType_IsValid(int value) {
case 9:
case 10:
case 11:
case 12:
return true;
default:
return false;
}
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> V1Frame_FrameType_strings[12] = {};
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> V1Frame_FrameType_strings[13] = {};
static const char V1Frame_FrameType_names[] =
"AUTHENTICATION_MESSAGE"
@@ -656,6 +671,7 @@ static const char V1Frame_FrameType_names[] =
"AUTO_RECONNECT"
"AUTO_RESUME"
"BANDWIDTH_UPGRADE_NEGOTIATION"
"BANDWIDTH_UPGRADE_RETRY"
"CONNECTION_REQUEST"
"CONNECTION_RESPONSE"
"DISCONNECTION"
@@ -670,28 +686,30 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry V1Frame_FrameType_entr
{ {V1Frame_FrameType_names + 43, 14}, 11 },
{ {V1Frame_FrameType_names + 57, 11}, 10 },
{ {V1Frame_FrameType_names + 68, 29}, 4 },
{ {V1Frame_FrameType_names + 97, 18}, 1 },
{ {V1Frame_FrameType_names + 115, 19}, 2 },
{ {V1Frame_FrameType_names + 134, 13}, 6 },
{ {V1Frame_FrameType_names + 147, 10}, 5 },
{ {V1Frame_FrameType_names + 157, 21}, 7 },
{ {V1Frame_FrameType_names + 178, 16}, 3 },
{ {V1Frame_FrameType_names + 194, 18}, 0 },
{ {V1Frame_FrameType_names + 97, 23}, 12 },
{ {V1Frame_FrameType_names + 120, 18}, 1 },
{ {V1Frame_FrameType_names + 138, 19}, 2 },
{ {V1Frame_FrameType_names + 157, 13}, 6 },
{ {V1Frame_FrameType_names + 170, 10}, 5 },
{ {V1Frame_FrameType_names + 180, 21}, 7 },
{ {V1Frame_FrameType_names + 201, 16}, 3 },
{ {V1Frame_FrameType_names + 217, 18}, 0 },
};
static const int V1Frame_FrameType_entries_by_number[] = {
11, // 0 -> UNKNOWN_FRAME_TYPE
5, // 1 -> CONNECTION_REQUEST
6, // 2 -> CONNECTION_RESPONSE
10, // 3 -> PAYLOAD_TRANSFER
12, // 0 -> UNKNOWN_FRAME_TYPE
6, // 1 -> CONNECTION_REQUEST
7, // 2 -> CONNECTION_RESPONSE
11, // 3 -> PAYLOAD_TRANSFER
4, // 4 -> BANDWIDTH_UPGRADE_NEGOTIATION
8, // 5 -> KEEP_ALIVE
7, // 6 -> DISCONNECTION
9, // 7 -> PAIRED_KEY_ENCRYPTION
9, // 5 -> KEEP_ALIVE
8, // 6 -> DISCONNECTION
10, // 7 -> PAIRED_KEY_ENCRYPTION
0, // 8 -> AUTHENTICATION_MESSAGE
1, // 9 -> AUTHENTICATION_RESULT
3, // 10 -> AUTO_RESUME
2, // 11 -> AUTO_RECONNECT
5, // 12 -> BANDWIDTH_UPGRADE_RETRY
};
const std::string& V1Frame_FrameType_Name(
@@ -700,12 +718,12 @@ const std::string& V1Frame_FrameType_Name(
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
V1Frame_FrameType_entries,
V1Frame_FrameType_entries_by_number,
12, V1Frame_FrameType_strings);
13, V1Frame_FrameType_strings);
(void) dummy;
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
V1Frame_FrameType_entries,
V1Frame_FrameType_entries_by_number,
12, value);
13, value);
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
V1Frame_FrameType_strings[idx].get();
}
@@ -713,7 +731,7 @@ bool V1Frame_FrameType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V1Frame_FrameType* value) {
int int_value;
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
V1Frame_FrameType_entries, 12, name, &int_value);
V1Frame_FrameType_entries, 13, name, &int_value);
if (success) {
*value = static_cast<V1Frame_FrameType>(int_value);
}
@@ -732,6 +750,7 @@ constexpr V1Frame_FrameType V1Frame::AUTHENTICATION_MESSAGE;
constexpr V1Frame_FrameType V1Frame::AUTHENTICATION_RESULT;
constexpr V1Frame_FrameType V1Frame::AUTO_RESUME;
constexpr V1Frame_FrameType V1Frame::AUTO_RECONNECT;
constexpr V1Frame_FrameType V1Frame::BANDWIDTH_UPGRADE_RETRY;
constexpr V1Frame_FrameType V1Frame::FrameType_MIN;
constexpr V1Frame_FrameType V1Frame::FrameType_MAX;
constexpr int V1Frame::FrameType_ARRAYSIZE;
@@ -1101,29 +1120,33 @@ bool PayloadTransferFrame_PacketType_IsValid(int value) {
case 0:
case 1:
case 2:
case 3:
return true;
default:
return false;
}
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PayloadTransferFrame_PacketType_strings[3] = {};
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PayloadTransferFrame_PacketType_strings[4] = {};
static const char PayloadTransferFrame_PacketType_names[] =
"CONTROL"
"DATA"
"PAYLOAD_ACK"
"UNKNOWN_PACKET_TYPE";
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PayloadTransferFrame_PacketType_entries[] = {
{ {PayloadTransferFrame_PacketType_names + 0, 7}, 2 },
{ {PayloadTransferFrame_PacketType_names + 7, 4}, 1 },
{ {PayloadTransferFrame_PacketType_names + 11, 19}, 0 },
{ {PayloadTransferFrame_PacketType_names + 11, 11}, 3 },
{ {PayloadTransferFrame_PacketType_names + 22, 19}, 0 },
};
static const int PayloadTransferFrame_PacketType_entries_by_number[] = {
2, // 0 -> UNKNOWN_PACKET_TYPE
3, // 0 -> UNKNOWN_PACKET_TYPE
1, // 1 -> DATA
0, // 2 -> CONTROL
2, // 3 -> PAYLOAD_ACK
};
const std::string& PayloadTransferFrame_PacketType_Name(
@@ -1132,12 +1155,12 @@ const std::string& PayloadTransferFrame_PacketType_Name(
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
PayloadTransferFrame_PacketType_entries,
PayloadTransferFrame_PacketType_entries_by_number,
3, PayloadTransferFrame_PacketType_strings);
4, PayloadTransferFrame_PacketType_strings);
(void) dummy;
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
PayloadTransferFrame_PacketType_entries,
PayloadTransferFrame_PacketType_entries_by_number,
3, value);
4, value);
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
PayloadTransferFrame_PacketType_strings[idx].get();
}
@@ -1145,7 +1168,7 @@ bool PayloadTransferFrame_PacketType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadTransferFrame_PacketType* value) {
int int_value;
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
PayloadTransferFrame_PacketType_entries, 3, name, &int_value);
PayloadTransferFrame_PacketType_entries, 4, name, &int_value);
if (success) {
*value = static_cast<PayloadTransferFrame_PacketType>(int_value);
}
@@ -1155,6 +1178,7 @@ bool PayloadTransferFrame_PacketType_Parse(
constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::UNKNOWN_PACKET_TYPE;
constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::DATA;
constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::CONTROL;
constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::PAYLOAD_ACK;
constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::PacketType_MIN;
constexpr PayloadTransferFrame_PacketType PayloadTransferFrame::PacketType_MAX;
constexpr int PayloadTransferFrame::PacketType_ARRAYSIZE;
@@ -1345,6 +1369,109 @@ constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiation
constexpr BandwidthUpgradeNegotiationFrame_EventType BandwidthUpgradeNegotiationFrame::EventType_MAX;
constexpr int BandwidthUpgradeNegotiationFrame::EventType_ARRAYSIZE;
#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool BandwidthUpgradeRetryFrame_Medium_IsValid(int value) {
switch (value) {
case 0:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
return true;
default:
return false;
}
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> BandwidthUpgradeRetryFrame_Medium_strings[11] = {};
static const char BandwidthUpgradeRetryFrame_Medium_names[] =
"BLE"
"BLE_L2CAP"
"BLUETOOTH"
"NFC"
"UNKNOWN_MEDIUM"
"USB"
"WEB_RTC"
"WIFI_AWARE"
"WIFI_DIRECT"
"WIFI_HOTSPOT"
"WIFI_LAN";
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BandwidthUpgradeRetryFrame_Medium_entries[] = {
{ {BandwidthUpgradeRetryFrame_Medium_names + 0, 3}, 4 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 3, 9}, 10 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 12, 9}, 2 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 21, 3}, 7 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 24, 14}, 0 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 38, 3}, 11 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 41, 7}, 9 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 48, 10}, 6 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 58, 11}, 8 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 69, 12}, 3 },
{ {BandwidthUpgradeRetryFrame_Medium_names + 81, 8}, 5 },
};
static const int BandwidthUpgradeRetryFrame_Medium_entries_by_number[] = {
4, // 0 -> UNKNOWN_MEDIUM
2, // 2 -> BLUETOOTH
9, // 3 -> WIFI_HOTSPOT
0, // 4 -> BLE
10, // 5 -> WIFI_LAN
7, // 6 -> WIFI_AWARE
3, // 7 -> NFC
8, // 8 -> WIFI_DIRECT
6, // 9 -> WEB_RTC
1, // 10 -> BLE_L2CAP
5, // 11 -> USB
};
const std::string& BandwidthUpgradeRetryFrame_Medium_Name(
BandwidthUpgradeRetryFrame_Medium value) {
static const bool dummy =
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
BandwidthUpgradeRetryFrame_Medium_entries,
BandwidthUpgradeRetryFrame_Medium_entries_by_number,
11, BandwidthUpgradeRetryFrame_Medium_strings);
(void) dummy;
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
BandwidthUpgradeRetryFrame_Medium_entries,
BandwidthUpgradeRetryFrame_Medium_entries_by_number,
11, value);
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
BandwidthUpgradeRetryFrame_Medium_strings[idx].get();
}
bool BandwidthUpgradeRetryFrame_Medium_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeRetryFrame_Medium* value) {
int int_value;
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
BandwidthUpgradeRetryFrame_Medium_entries, 11, name, &int_value);
if (success) {
*value = static_cast<BandwidthUpgradeRetryFrame_Medium>(int_value);
}
return success;
}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::UNKNOWN_MEDIUM;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::BLUETOOTH;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WIFI_HOTSPOT;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::BLE;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WIFI_LAN;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WIFI_AWARE;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::NFC;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WIFI_DIRECT;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::WEB_RTC;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::BLE_L2CAP;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::USB;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::Medium_MIN;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::Medium_MAX;
constexpr int BandwidthUpgradeRetryFrame::Medium_ARRAYSIZE;
#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool AutoResumeFrame_EventType_IsValid(int value) {
switch (value) {
case 0:
@@ -2009,7 +2136,7 @@ class V1Frame::_Internal {
public:
using HasBits = decltype(std::declval<V1Frame>()._has_bits_);
static void set_has_type(HasBits* has_bits) {
(*has_bits)[0] |= 2048u;
(*has_bits)[0] |= 4096u;
}
static const ::location::nearby::connections::ConnectionRequestFrame& connection_request(const V1Frame* msg);
static void set_has_connection_request(HasBits* has_bits) {
@@ -2055,6 +2182,10 @@ class V1Frame::_Internal {
static void set_has_auto_reconnect(HasBits* has_bits) {
(*has_bits)[0] |= 1024u;
}
static const ::location::nearby::connections::BandwidthUpgradeRetryFrame& bandwidth_upgrade_retry(const V1Frame* msg);
static void set_has_bandwidth_upgrade_retry(HasBits* has_bits) {
(*has_bits)[0] |= 2048u;
}
};
const ::location::nearby::connections::ConnectionRequestFrame&
@@ -2101,6 +2232,10 @@ const ::location::nearby::connections::AutoReconnectFrame&
V1Frame::_Internal::auto_reconnect(const V1Frame* msg) {
return *msg->auto_reconnect_;
}
const ::location::nearby::connections::BandwidthUpgradeRetryFrame&
V1Frame::_Internal::bandwidth_upgrade_retry(const V1Frame* msg) {
return *msg->bandwidth_upgrade_retry_;
}
V1Frame::V1Frame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
@@ -2169,6 +2304,11 @@ V1Frame::V1Frame(const V1Frame& from)
} else {
auto_reconnect_ = nullptr;
}
if (from._internal_has_bandwidth_upgrade_retry()) {
bandwidth_upgrade_retry_ = new ::location::nearby::connections::BandwidthUpgradeRetryFrame(*from.bandwidth_upgrade_retry_);
} else {
bandwidth_upgrade_retry_ = nullptr;
}
type_ = from.type_;
// @@protoc_insertion_point(copy_constructor:location.nearby.connections.V1Frame)
}
@@ -2200,6 +2340,7 @@ inline void V1Frame::SharedDtor() {
if (this != internal_default_instance()) delete authentication_result_;
if (this != internal_default_instance()) delete auto_resume_;
if (this != internal_default_instance()) delete auto_reconnect_;
if (this != internal_default_instance()) delete bandwidth_upgrade_retry_;
}
void V1Frame::ArenaDtor(void* object) {
@@ -2253,7 +2394,7 @@ void V1Frame::Clear() {
authentication_message_->Clear();
}
}
if (cached_has_bits & 0x00000700u) {
if (cached_has_bits & 0x00000f00u) {
if (cached_has_bits & 0x00000100u) {
GOOGLE_DCHECK(authentication_result_ != nullptr);
authentication_result_->Clear();
@@ -2266,6 +2407,10 @@ void V1Frame::Clear() {
GOOGLE_DCHECK(auto_reconnect_ != nullptr);
auto_reconnect_->Clear();
}
if (cached_has_bits & 0x00000800u) {
GOOGLE_DCHECK(bandwidth_upgrade_retry_ != nullptr);
bandwidth_upgrade_retry_->Clear();
}
}
type_ = 0;
_has_bits_.Clear();
@@ -2380,6 +2525,14 @@ const char* V1Frame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in
} else
goto handle_unusual;
continue;
// optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13;
case 13:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
ptr = ctx->ParseMessage(_internal_mutable_bandwidth_upgrade_retry(), ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
@@ -2412,7 +2565,7 @@ uint8_t* V1Frame::_InternalSerialize(
cached_has_bits = _has_bits_[0];
// optional .location.nearby.connections.V1Frame.FrameType type = 1;
if (cached_has_bits & 0x00000800u) {
if (cached_has_bits & 0x00001000u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
1, this->_internal_type(), target);
@@ -2506,6 +2659,14 @@ uint8_t* V1Frame::_InternalSerialize(
12, _Internal::auto_reconnect(this), target, stream);
}
// optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13;
if (cached_has_bits & 0x00000800u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
InternalWriteMessage(
13, _Internal::bandwidth_upgrade_retry(this), target, stream);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
@@ -2581,7 +2742,7 @@ size_t V1Frame::ByteSizeLong() const {
}
}
if (cached_has_bits & 0x00000f00u) {
if (cached_has_bits & 0x00001f00u) {
// optional .location.nearby.connections.AuthenticationResultFrame authentication_result = 10;
if (cached_has_bits & 0x00000100u) {
total_size += 1 +
@@ -2603,8 +2764,15 @@ size_t V1Frame::ByteSizeLong() const {
*auto_reconnect_);
}
// optional .location.nearby.connections.V1Frame.FrameType type = 1;
// optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13;
if (cached_has_bits & 0x00000800u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
*bandwidth_upgrade_retry_);
}
// optional .location.nearby.connections.V1Frame.FrameType type = 1;
if (cached_has_bits & 0x00001000u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
}
@@ -2657,7 +2825,7 @@ void V1Frame::MergeFrom(const V1Frame& from) {
_internal_mutable_authentication_message()->::location::nearby::connections::AuthenticationMessageFrame::MergeFrom(from._internal_authentication_message());
}
}
if (cached_has_bits & 0x00000f00u) {
if (cached_has_bits & 0x00001f00u) {
if (cached_has_bits & 0x00000100u) {
_internal_mutable_authentication_result()->::location::nearby::connections::AuthenticationResultFrame::MergeFrom(from._internal_authentication_result());
}
@@ -2668,6 +2836,9 @@ void V1Frame::MergeFrom(const V1Frame& from) {
_internal_mutable_auto_reconnect()->::location::nearby::connections::AutoReconnectFrame::MergeFrom(from._internal_auto_reconnect());
}
if (cached_has_bits & 0x00000800u) {
_internal_mutable_bandwidth_upgrade_retry()->::location::nearby::connections::BandwidthUpgradeRetryFrame::MergeFrom(from._internal_bandwidth_upgrade_retry());
}
if (cached_has_bits & 0x00001000u) {
type_ = from.type_;
}
_has_bits_[0] |= cached_has_bits;
@@ -8338,6 +8509,236 @@ std::string BandwidthUpgradeNegotiationFrame::GetTypeName() const {
}
// ===================================================================
class BandwidthUpgradeRetryFrame::_Internal {
public:
using HasBits = decltype(std::declval<BandwidthUpgradeRetryFrame>()._has_bits_);
static void set_has_is_request(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
};
BandwidthUpgradeRetryFrame::BandwidthUpgradeRetryFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned),
supported_medium_(arena) {
SharedCtor();
if (!is_message_owned) {
RegisterArenaDtor(arena);
}
// @@protoc_insertion_point(arena_constructor:location.nearby.connections.BandwidthUpgradeRetryFrame)
}
BandwidthUpgradeRetryFrame::BandwidthUpgradeRetryFrame(const BandwidthUpgradeRetryFrame& from)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
_has_bits_(from._has_bits_),
supported_medium_(from.supported_medium_) {
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
is_request_ = from.is_request_;
// @@protoc_insertion_point(copy_constructor:location.nearby.connections.BandwidthUpgradeRetryFrame)
}
inline void BandwidthUpgradeRetryFrame::SharedCtor() {
is_request_ = false;
}
BandwidthUpgradeRetryFrame::~BandwidthUpgradeRetryFrame() {
// @@protoc_insertion_point(destructor:location.nearby.connections.BandwidthUpgradeRetryFrame)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<std::string>();
}
inline void BandwidthUpgradeRetryFrame::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}
void BandwidthUpgradeRetryFrame::ArenaDtor(void* object) {
BandwidthUpgradeRetryFrame* _this = reinterpret_cast< BandwidthUpgradeRetryFrame* >(object);
(void)_this;
}
void BandwidthUpgradeRetryFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void BandwidthUpgradeRetryFrame::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void BandwidthUpgradeRetryFrame::Clear() {
// @@protoc_insertion_point(message_clear_start:location.nearby.connections.BandwidthUpgradeRetryFrame)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
supported_medium_.Clear();
is_request_ = false;
_has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
}
const char* BandwidthUpgradeRetryFrame::_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 .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
ptr -= 1;
do {
ptr += 1;
uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium_IsValid(val))) {
_internal_add_supported_medium(static_cast<::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium>(val));
} else {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
}
if (!ctx->DataAvailable(ptr)) break;
} while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
} else if (static_cast<uint8_t>(tag) == 10) {
ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<std::string>(_internal_mutable_supported_medium(), ptr, ctx, ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium_IsValid, &_internal_metadata_, 1);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional bool is_request = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
_Internal::set_has_is_request(&has_bits);
is_request_ = ::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<std::string>(),
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* BandwidthUpgradeRetryFrame::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.BandwidthUpgradeRetryFrame)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
// repeated .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1;
for (int i = 0, n = this->_internal_supported_medium_size(); i < n; i++) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
1, this->_internal_supported_medium(i), target);
}
cached_has_bits = _has_bits_[0];
// optional bool is_request = 2;
if (cached_has_bits & 0x00000001u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_is_request(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
}
// @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.BandwidthUpgradeRetryFrame)
return target;
}
size_t BandwidthUpgradeRetryFrame::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.BandwidthUpgradeRetryFrame)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
// repeated .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1;
{
size_t data_size = 0;
unsigned int count = static_cast<unsigned int>(this->_internal_supported_medium_size());for (unsigned int i = 0; i < count; i++) {
data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
this->_internal_supported_medium(static_cast<int>(i)));
}
total_size += (1UL * count) + data_size;
}
// optional bool is_request = 2;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000001u) {
total_size += 1 + 1;
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
}
int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
SetCachedSize(cached_size);
return total_size;
}
void BandwidthUpgradeRetryFrame::CheckTypeAndMergeFrom(
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const BandwidthUpgradeRetryFrame*>(
&from));
}
void BandwidthUpgradeRetryFrame::MergeFrom(const BandwidthUpgradeRetryFrame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.BandwidthUpgradeRetryFrame)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
supported_medium_.MergeFrom(from.supported_medium_);
if (from._internal_has_is_request()) {
_internal_set_is_request(from._internal_is_request());
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
void BandwidthUpgradeRetryFrame::CopyFrom(const BandwidthUpgradeRetryFrame& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.BandwidthUpgradeRetryFrame)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool BandwidthUpgradeRetryFrame::IsInitialized() const {
return true;
}
void BandwidthUpgradeRetryFrame::InternalSwap(BandwidthUpgradeRetryFrame* other) {
using std::swap;
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
supported_medium_.InternalSwap(&other->supported_medium_);
swap(is_request_, other->is_request_);
}
std::string BandwidthUpgradeRetryFrame::GetTypeName() const {
return "location.nearby.connections.BandwidthUpgradeRetryFrame";
}
// ===================================================================
class KeepAliveFrame::_Internal {
@@ -13083,6 +13484,9 @@ template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNe
template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeNegotiationFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame >(Arena* arena) {
return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame >(arena);
}
template<> PROTOBUF_NOINLINE ::location::nearby::connections::BandwidthUpgradeRetryFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::BandwidthUpgradeRetryFrame >(Arena* arena) {
return Arena::CreateMessageInternal< ::location::nearby::connections::BandwidthUpgradeRetryFrame >(arena);
}
template<> PROTOBUF_NOINLINE ::location::nearby::connections::KeepAliveFrame* Arena::CreateMaybeMessage< ::location::nearby::connections::KeepAliveFrame >(Arena* arena) {
return Arena::CreateMessageInternal< ::location::nearby::connections::KeepAliveFrame >(arena);
}
compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h
+461 -28
View File
@@ -45,7 +45,7 @@ struct TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fforma
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[36]
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[37]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
@@ -99,6 +99,9 @@ extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentialsDe
class BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket;
struct BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal;
extern BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocketDefaultTypeInternal _BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket_default_instance_;
class BandwidthUpgradeRetryFrame;
struct BandwidthUpgradeRetryFrameDefaultTypeInternal;
extern BandwidthUpgradeRetryFrameDefaultTypeInternal _BandwidthUpgradeRetryFrame_default_instance_;
class ConnectionRequestFrame;
struct ConnectionRequestFrameDefaultTypeInternal;
extern ConnectionRequestFrameDefaultTypeInternal _ConnectionRequestFrame_default_instance_;
@@ -181,6 +184,7 @@ template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_Upg
template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiDirectCredentials>(Arena*);
template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiHotspotCredentials>(Arena*);
template<> ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_WifiLanSocket>(Arena*);
template<> ::location::nearby::connections::BandwidthUpgradeRetryFrame* Arena::CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeRetryFrame>(Arena*);
template<> ::location::nearby::connections::ConnectionRequestFrame* Arena::CreateMaybeMessage<::location::nearby::connections::ConnectionRequestFrame>(Arena*);
template<> ::location::nearby::connections::ConnectionResponseFrame* Arena::CreateMaybeMessage<::location::nearby::connections::ConnectionResponseFrame>(Arena*);
template<> ::location::nearby::connections::ConnectionsDevice* Arena::CreateMaybeMessage<::location::nearby::connections::ConnectionsDevice>(Arena*);
@@ -238,11 +242,12 @@ enum V1Frame_FrameType : int {
V1Frame_FrameType_AUTHENTICATION_MESSAGE = 8,
V1Frame_FrameType_AUTHENTICATION_RESULT = 9,
V1Frame_FrameType_AUTO_RESUME = 10,
V1Frame_FrameType_AUTO_RECONNECT = 11
V1Frame_FrameType_AUTO_RECONNECT = 11,
V1Frame_FrameType_BANDWIDTH_UPGRADE_RETRY = 12
};
bool V1Frame_FrameType_IsValid(int value);
constexpr V1Frame_FrameType V1Frame_FrameType_FrameType_MIN = V1Frame_FrameType_UNKNOWN_FRAME_TYPE;
constexpr V1Frame_FrameType V1Frame_FrameType_FrameType_MAX = V1Frame_FrameType_AUTO_RECONNECT;
constexpr V1Frame_FrameType V1Frame_FrameType_FrameType_MAX = V1Frame_FrameType_BANDWIDTH_UPGRADE_RETRY;
constexpr int V1Frame_FrameType_FrameType_ARRAYSIZE = V1Frame_FrameType_FrameType_MAX + 1;
const std::string& V1Frame_FrameType_Name(V1Frame_FrameType value);
@@ -347,7 +352,7 @@ enum PayloadTransferFrame_ControlMessage_EventType : int {
PayloadTransferFrame_ControlMessage_EventType_UNKNOWN_EVENT_TYPE = 0,
PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_ERROR = 1,
PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_CANCELED = 2,
PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_RECEIVED_ACK = 3
PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_RECEIVED_ACK PROTOBUF_DEPRECATED_ENUM = 3
};
bool PayloadTransferFrame_ControlMessage_EventType_IsValid(int value);
constexpr PayloadTransferFrame_ControlMessage_EventType PayloadTransferFrame_ControlMessage_EventType_EventType_MIN = PayloadTransferFrame_ControlMessage_EventType_UNKNOWN_EVENT_TYPE;
@@ -367,11 +372,12 @@ bool PayloadTransferFrame_ControlMessage_EventType_Parse(
enum PayloadTransferFrame_PacketType : int {
PayloadTransferFrame_PacketType_UNKNOWN_PACKET_TYPE = 0,
PayloadTransferFrame_PacketType_DATA = 1,
PayloadTransferFrame_PacketType_CONTROL = 2
PayloadTransferFrame_PacketType_CONTROL = 2,
PayloadTransferFrame_PacketType_PAYLOAD_ACK = 3
};
bool PayloadTransferFrame_PacketType_IsValid(int value);
constexpr PayloadTransferFrame_PacketType PayloadTransferFrame_PacketType_PacketType_MIN = PayloadTransferFrame_PacketType_UNKNOWN_PACKET_TYPE;
constexpr PayloadTransferFrame_PacketType PayloadTransferFrame_PacketType_PacketType_MAX = PayloadTransferFrame_PacketType_CONTROL;
constexpr PayloadTransferFrame_PacketType PayloadTransferFrame_PacketType_PacketType_MAX = PayloadTransferFrame_PacketType_PAYLOAD_ACK;
constexpr int PayloadTransferFrame_PacketType_PacketType_ARRAYSIZE = PayloadTransferFrame_PacketType_PacketType_MAX + 1;
const std::string& PayloadTransferFrame_PacketType_Name(PayloadTransferFrame_PacketType value);
@@ -436,6 +442,34 @@ inline const std::string& BandwidthUpgradeNegotiationFrame_EventType_Name(T enum
}
bool BandwidthUpgradeNegotiationFrame_EventType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeNegotiationFrame_EventType* value);
enum BandwidthUpgradeRetryFrame_Medium : int {
BandwidthUpgradeRetryFrame_Medium_UNKNOWN_MEDIUM = 0,
BandwidthUpgradeRetryFrame_Medium_BLUETOOTH = 2,
BandwidthUpgradeRetryFrame_Medium_WIFI_HOTSPOT = 3,
BandwidthUpgradeRetryFrame_Medium_BLE = 4,
BandwidthUpgradeRetryFrame_Medium_WIFI_LAN = 5,
BandwidthUpgradeRetryFrame_Medium_WIFI_AWARE = 6,
BandwidthUpgradeRetryFrame_Medium_NFC = 7,
BandwidthUpgradeRetryFrame_Medium_WIFI_DIRECT = 8,
BandwidthUpgradeRetryFrame_Medium_WEB_RTC = 9,
BandwidthUpgradeRetryFrame_Medium_BLE_L2CAP = 10,
BandwidthUpgradeRetryFrame_Medium_USB = 11
};
bool BandwidthUpgradeRetryFrame_Medium_IsValid(int value);
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame_Medium_Medium_MIN = BandwidthUpgradeRetryFrame_Medium_UNKNOWN_MEDIUM;
constexpr BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame_Medium_Medium_MAX = BandwidthUpgradeRetryFrame_Medium_USB;
constexpr int BandwidthUpgradeRetryFrame_Medium_Medium_ARRAYSIZE = BandwidthUpgradeRetryFrame_Medium_Medium_MAX + 1;
const std::string& BandwidthUpgradeRetryFrame_Medium_Name(BandwidthUpgradeRetryFrame_Medium value);
template<typename T>
inline const std::string& BandwidthUpgradeRetryFrame_Medium_Name(T enum_t_value) {
static_assert(::std::is_same<T, BandwidthUpgradeRetryFrame_Medium>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function BandwidthUpgradeRetryFrame_Medium_Name.");
return BandwidthUpgradeRetryFrame_Medium_Name(static_cast<BandwidthUpgradeRetryFrame_Medium>(enum_t_value));
}
bool BandwidthUpgradeRetryFrame_Medium_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeRetryFrame_Medium* value);
enum AutoResumeFrame_EventType : int {
AutoResumeFrame_EventType_UNKNOWN_AUTO_RESUME_EVENT_TYPE = 0,
AutoResumeFrame_EventType_PAYLOAD_RESUME_TRANSFER_START = 1,
@@ -888,6 +922,8 @@ class V1Frame final :
V1Frame_FrameType_AUTO_RESUME;
static constexpr FrameType AUTO_RECONNECT =
V1Frame_FrameType_AUTO_RECONNECT;
static constexpr FrameType BANDWIDTH_UPGRADE_RETRY =
V1Frame_FrameType_BANDWIDTH_UPGRADE_RETRY;
static inline bool FrameType_IsValid(int value) {
return V1Frame_FrameType_IsValid(value);
}
@@ -923,6 +959,7 @@ class V1Frame final :
kAuthenticationResultFieldNumber = 10,
kAutoResumeFieldNumber = 11,
kAutoReconnectFieldNumber = 12,
kBandwidthUpgradeRetryFieldNumber = 13,
kTypeFieldNumber = 1,
};
// optional .location.nearby.connections.ConnectionRequestFrame connection_request = 2;
@@ -1123,6 +1160,24 @@ class V1Frame final :
::location::nearby::connections::AutoReconnectFrame* auto_reconnect);
::location::nearby::connections::AutoReconnectFrame* unsafe_arena_release_auto_reconnect();
// optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13;
bool has_bandwidth_upgrade_retry() const;
private:
bool _internal_has_bandwidth_upgrade_retry() const;
public:
void clear_bandwidth_upgrade_retry();
const ::location::nearby::connections::BandwidthUpgradeRetryFrame& bandwidth_upgrade_retry() const;
PROTOBUF_NODISCARD ::location::nearby::connections::BandwidthUpgradeRetryFrame* release_bandwidth_upgrade_retry();
::location::nearby::connections::BandwidthUpgradeRetryFrame* mutable_bandwidth_upgrade_retry();
void set_allocated_bandwidth_upgrade_retry(::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry);
private:
const ::location::nearby::connections::BandwidthUpgradeRetryFrame& _internal_bandwidth_upgrade_retry() const;
::location::nearby::connections::BandwidthUpgradeRetryFrame* _internal_mutable_bandwidth_upgrade_retry();
public:
void unsafe_arena_set_allocated_bandwidth_upgrade_retry(
::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry);
::location::nearby::connections::BandwidthUpgradeRetryFrame* unsafe_arena_release_bandwidth_upgrade_retry();
// optional .location.nearby.connections.V1Frame.FrameType type = 1;
bool has_type() const;
private:
@@ -1156,6 +1211,7 @@ class V1Frame final :
::location::nearby::connections::AuthenticationResultFrame* authentication_result_;
::location::nearby::connections::AutoResumeFrame* auto_resume_;
::location::nearby::connections::AutoReconnectFrame* auto_reconnect_;
::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry_;
int type_;
friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto;
};
@@ -2452,7 +2508,7 @@ class PayloadTransferFrame_ControlMessage final :
PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_ERROR;
static constexpr EventType PAYLOAD_CANCELED =
PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_CANCELED;
static constexpr EventType PAYLOAD_RECEIVED_ACK =
PROTOBUF_DEPRECATED_ENUM static constexpr EventType PAYLOAD_RECEIVED_ACK =
PayloadTransferFrame_ControlMessage_EventType_PAYLOAD_RECEIVED_ACK;
static inline bool EventType_IsValid(int value) {
return PayloadTransferFrame_ControlMessage_EventType_IsValid(value);
@@ -2643,6 +2699,8 @@ class PayloadTransferFrame final :
PayloadTransferFrame_PacketType_DATA;
static constexpr PacketType CONTROL =
PayloadTransferFrame_PacketType_CONTROL;
static constexpr PacketType PAYLOAD_ACK =
PayloadTransferFrame_PacketType_PAYLOAD_ACK;
static inline bool PacketType_IsValid(int value) {
return PayloadTransferFrame_PacketType_IsValid(value);
}
@@ -4766,6 +4824,211 @@ class BandwidthUpgradeNegotiationFrame final :
};
// -------------------------------------------------------------------
class BandwidthUpgradeRetryFrame final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.BandwidthUpgradeRetryFrame) */ {
public:
inline BandwidthUpgradeRetryFrame() : BandwidthUpgradeRetryFrame(nullptr) {}
~BandwidthUpgradeRetryFrame() override;
explicit constexpr BandwidthUpgradeRetryFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
BandwidthUpgradeRetryFrame(const BandwidthUpgradeRetryFrame& from);
BandwidthUpgradeRetryFrame(BandwidthUpgradeRetryFrame&& from) noexcept
: BandwidthUpgradeRetryFrame() {
*this = ::std::move(from);
}
inline BandwidthUpgradeRetryFrame& operator=(const BandwidthUpgradeRetryFrame& from) {
CopyFrom(from);
return *this;
}
inline BandwidthUpgradeRetryFrame& operator=(BandwidthUpgradeRetryFrame&& 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<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
}
inline std::string* mutable_unknown_fields() {
return _internal_metadata_.mutable_unknown_fields<std::string>();
}
static const BandwidthUpgradeRetryFrame& default_instance() {
return *internal_default_instance();
}
static inline const BandwidthUpgradeRetryFrame* internal_default_instance() {
return reinterpret_cast<const BandwidthUpgradeRetryFrame*>(
&_BandwidthUpgradeRetryFrame_default_instance_);
}
static constexpr int kIndexInFileMessages =
18;
friend void swap(BandwidthUpgradeRetryFrame& a, BandwidthUpgradeRetryFrame& b) {
a.Swap(&b);
}
inline void Swap(BandwidthUpgradeRetryFrame* 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(BandwidthUpgradeRetryFrame* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
BandwidthUpgradeRetryFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<BandwidthUpgradeRetryFrame>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const BandwidthUpgradeRetryFrame& from);
void MergeFrom(const BandwidthUpgradeRetryFrame& 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(BandwidthUpgradeRetryFrame* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "location.nearby.connections.BandwidthUpgradeRetryFrame";
}
protected:
explicit BandwidthUpgradeRetryFrame(::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 BandwidthUpgradeRetryFrame_Medium Medium;
static constexpr Medium UNKNOWN_MEDIUM =
BandwidthUpgradeRetryFrame_Medium_UNKNOWN_MEDIUM;
static constexpr Medium BLUETOOTH =
BandwidthUpgradeRetryFrame_Medium_BLUETOOTH;
static constexpr Medium WIFI_HOTSPOT =
BandwidthUpgradeRetryFrame_Medium_WIFI_HOTSPOT;
static constexpr Medium BLE =
BandwidthUpgradeRetryFrame_Medium_BLE;
static constexpr Medium WIFI_LAN =
BandwidthUpgradeRetryFrame_Medium_WIFI_LAN;
static constexpr Medium WIFI_AWARE =
BandwidthUpgradeRetryFrame_Medium_WIFI_AWARE;
static constexpr Medium NFC =
BandwidthUpgradeRetryFrame_Medium_NFC;
static constexpr Medium WIFI_DIRECT =
BandwidthUpgradeRetryFrame_Medium_WIFI_DIRECT;
static constexpr Medium WEB_RTC =
BandwidthUpgradeRetryFrame_Medium_WEB_RTC;
static constexpr Medium BLE_L2CAP =
BandwidthUpgradeRetryFrame_Medium_BLE_L2CAP;
static constexpr Medium USB =
BandwidthUpgradeRetryFrame_Medium_USB;
static inline bool Medium_IsValid(int value) {
return BandwidthUpgradeRetryFrame_Medium_IsValid(value);
}
static constexpr Medium Medium_MIN =
BandwidthUpgradeRetryFrame_Medium_Medium_MIN;
static constexpr Medium Medium_MAX =
BandwidthUpgradeRetryFrame_Medium_Medium_MAX;
static constexpr int Medium_ARRAYSIZE =
BandwidthUpgradeRetryFrame_Medium_Medium_ARRAYSIZE;
template<typename T>
static inline const std::string& Medium_Name(T enum_t_value) {
static_assert(::std::is_same<T, Medium>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Medium_Name.");
return BandwidthUpgradeRetryFrame_Medium_Name(enum_t_value);
}
static inline bool Medium_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
Medium* value) {
return BandwidthUpgradeRetryFrame_Medium_Parse(name, value);
}
// accessors -------------------------------------------------------
enum : int {
kSupportedMediumFieldNumber = 1,
kIsRequestFieldNumber = 2,
};
// repeated .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1;
int supported_medium_size() const;
private:
int _internal_supported_medium_size() const;
public:
void clear_supported_medium();
private:
::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium _internal_supported_medium(int index) const;
void _internal_add_supported_medium(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value);
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_medium();
public:
::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium supported_medium(int index) const;
void set_supported_medium(int index, ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value);
void add_supported_medium(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value);
const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_medium() const;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_medium();
// optional bool is_request = 2;
bool has_is_request() const;
private:
bool _internal_has_is_request() const;
public:
void clear_is_request();
bool is_request() const;
void set_is_request(bool value);
private:
bool _internal_is_request() const;
void _internal_set_is_request(bool value);
public:
// @@protoc_insertion_point(class_scope:location.nearby.connections.BandwidthUpgradeRetryFrame)
private:
class _Internal;
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_medium_;
bool is_request_;
friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto;
};
// -------------------------------------------------------------------
class KeepAliveFrame final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.KeepAliveFrame) */ {
public:
@@ -4812,7 +5075,7 @@ class KeepAliveFrame final :
&_KeepAliveFrame_default_instance_);
}
static constexpr int kIndexInFileMessages =
18;
19;
friend void swap(KeepAliveFrame& a, KeepAliveFrame& b) {
a.Swap(&b);
@@ -4969,7 +5232,7 @@ class DisconnectionFrame final :
&_DisconnectionFrame_default_instance_);
}
static constexpr int kIndexInFileMessages =
19;
20;
friend void swap(DisconnectionFrame& a, DisconnectionFrame& b) {
a.Swap(&b);
@@ -5126,7 +5389,7 @@ class PairedKeyEncryptionFrame final :
&_PairedKeyEncryptionFrame_default_instance_);
}
static constexpr int kIndexInFileMessages =
20;
21;
friend void swap(PairedKeyEncryptionFrame& a, PairedKeyEncryptionFrame& b) {
a.Swap(&b);
@@ -5273,7 +5536,7 @@ class AuthenticationMessageFrame final :
&_AuthenticationMessageFrame_default_instance_);
}
static constexpr int kIndexInFileMessages =
21;
22;
friend void swap(AuthenticationMessageFrame& a, AuthenticationMessageFrame& b) {
a.Swap(&b);
@@ -5420,7 +5683,7 @@ class AuthenticationResultFrame final :
&_AuthenticationResultFrame_default_instance_);
}
static constexpr int kIndexInFileMessages =
22;
23;
friend void swap(AuthenticationResultFrame& a, AuthenticationResultFrame& b) {
a.Swap(&b);
@@ -5562,7 +5825,7 @@ class AutoResumeFrame final :
&_AutoResumeFrame_default_instance_);
}
static constexpr int kIndexInFileMessages =
23;
24;
friend void swap(AutoResumeFrame& a, AutoResumeFrame& b) {
a.Swap(&b);
@@ -5762,7 +6025,7 @@ class AutoReconnectFrame final :
&_AutoReconnectFrame_default_instance_);
}
static constexpr int kIndexInFileMessages =
24;
25;
friend void swap(AutoReconnectFrame& a, AutoReconnectFrame& b) {
a.Swap(&b);
@@ -5952,7 +6215,7 @@ class MediumMetadata final :
&_MediumMetadata_default_instance_);
}
static constexpr int kIndexInFileMessages =
25;
26;
friend void swap(MediumMetadata& a, MediumMetadata& b) {
a.Swap(&b);
@@ -6279,7 +6542,7 @@ class AvailableChannels final :
&_AvailableChannels_default_instance_);
}
static constexpr int kIndexInFileMessages =
26;
27;
friend void swap(AvailableChannels& a, AvailableChannels& b) {
a.Swap(&b);
@@ -6430,7 +6693,7 @@ class WifiDirectCliUsableChannels final :
&_WifiDirectCliUsableChannels_default_instance_);
}
static constexpr int kIndexInFileMessages =
27;
28;
friend void swap(WifiDirectCliUsableChannels& a, WifiDirectCliUsableChannels& b) {
a.Swap(&b);
@@ -6581,7 +6844,7 @@ class WifiLanUsableChannels final :
&_WifiLanUsableChannels_default_instance_);
}
static constexpr int kIndexInFileMessages =
28;
29;
friend void swap(WifiLanUsableChannels& a, WifiLanUsableChannels& b) {
a.Swap(&b);
@@ -6732,7 +6995,7 @@ class WifiAwareUsableChannels final :
&_WifiAwareUsableChannels_default_instance_);
}
static constexpr int kIndexInFileMessages =
29;
30;
friend void swap(WifiAwareUsableChannels& a, WifiAwareUsableChannels& b) {
a.Swap(&b);
@@ -6883,7 +7146,7 @@ class WifiHotspotStaUsableChannels final :
&_WifiHotspotStaUsableChannels_default_instance_);
}
static constexpr int kIndexInFileMessages =
30;
31;
friend void swap(WifiHotspotStaUsableChannels& a, WifiHotspotStaUsableChannels& b) {
a.Swap(&b);
@@ -7034,7 +7297,7 @@ class LocationHint final :
&_LocationHint_default_instance_);
}
static constexpr int kIndexInFileMessages =
31;
32;
friend void swap(LocationHint& a, LocationHint& b) {
a.Swap(&b);
@@ -7196,7 +7459,7 @@ class LocationStandard final :
&_LocationStandard_default_instance_);
}
static constexpr int kIndexInFileMessages =
32;
33;
friend void swap(LocationStandard& a, LocationStandard& b) {
a.Swap(&b);
@@ -7348,7 +7611,7 @@ class OsInfo final :
&_OsInfo_default_instance_);
}
static constexpr int kIndexInFileMessages =
33;
34;
friend void swap(OsInfo& a, OsInfo& b) {
a.Swap(&b);
@@ -7524,7 +7787,7 @@ class ConnectionsDevice final :
&_ConnectionsDevice_default_instance_);
}
static constexpr int kIndexInFileMessages =
34;
35;
friend void swap(ConnectionsDevice& a, ConnectionsDevice& b) {
a.Swap(&b);
@@ -7726,7 +7989,7 @@ class PresenceDevice final :
&_PresenceDevice_default_instance_);
}
static constexpr int kIndexInFileMessages =
35;
36;
friend void swap(PresenceDevice& a, PresenceDevice& b) {
a.Swap(&b);
@@ -8172,7 +8435,7 @@ inline void OfflineFrame::set_allocated_v1(::location::nearby::connections::V1Fr
// optional .location.nearby.connections.V1Frame.FrameType type = 1;
inline bool V1Frame::_internal_has_type() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
bool value = (_has_bits_[0] & 0x00001000u) != 0;
return value;
}
inline bool V1Frame::has_type() const {
@@ -8180,7 +8443,7 @@ inline bool V1Frame::has_type() const {
}
inline void V1Frame::clear_type() {
type_ = 0;
_has_bits_[0] &= ~0x00000800u;
_has_bits_[0] &= ~0x00001000u;
}
inline ::location::nearby::connections::V1Frame_FrameType V1Frame::_internal_type() const {
return static_cast< ::location::nearby::connections::V1Frame_FrameType >(type_);
@@ -8191,7 +8454,7 @@ inline ::location::nearby::connections::V1Frame_FrameType V1Frame::type() const
}
inline void V1Frame::_internal_set_type(::location::nearby::connections::V1Frame_FrameType value) {
assert(::location::nearby::connections::V1Frame_FrameType_IsValid(value));
_has_bits_[0] |= 0x00000800u;
_has_bits_[0] |= 0x00001000u;
type_ = value;
}
inline void V1Frame::set_type(::location::nearby::connections::V1Frame_FrameType value) {
@@ -9189,6 +9452,96 @@ inline void V1Frame::set_allocated_auto_reconnect(::location::nearby::connection
// @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.auto_reconnect)
}
// optional .location.nearby.connections.BandwidthUpgradeRetryFrame bandwidth_upgrade_retry = 13;
inline bool V1Frame::_internal_has_bandwidth_upgrade_retry() const {
bool value = (_has_bits_[0] & 0x00000800u) != 0;
PROTOBUF_ASSUME(!value || bandwidth_upgrade_retry_ != nullptr);
return value;
}
inline bool V1Frame::has_bandwidth_upgrade_retry() const {
return _internal_has_bandwidth_upgrade_retry();
}
inline void V1Frame::clear_bandwidth_upgrade_retry() {
if (bandwidth_upgrade_retry_ != nullptr) bandwidth_upgrade_retry_->Clear();
_has_bits_[0] &= ~0x00000800u;
}
inline const ::location::nearby::connections::BandwidthUpgradeRetryFrame& V1Frame::_internal_bandwidth_upgrade_retry() const {
const ::location::nearby::connections::BandwidthUpgradeRetryFrame* p = bandwidth_upgrade_retry_;
return p != nullptr ? *p : reinterpret_cast<const ::location::nearby::connections::BandwidthUpgradeRetryFrame&>(
::location::nearby::connections::_BandwidthUpgradeRetryFrame_default_instance_);
}
inline const ::location::nearby::connections::BandwidthUpgradeRetryFrame& V1Frame::bandwidth_upgrade_retry() const {
// @@protoc_insertion_point(field_get:location.nearby.connections.V1Frame.bandwidth_upgrade_retry)
return _internal_bandwidth_upgrade_retry();
}
inline void V1Frame::unsafe_arena_set_allocated_bandwidth_upgrade_retry(
::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry) {
if (GetArenaForAllocation() == nullptr) {
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bandwidth_upgrade_retry_);
}
bandwidth_upgrade_retry_ = bandwidth_upgrade_retry;
if (bandwidth_upgrade_retry) {
_has_bits_[0] |= 0x00000800u;
} else {
_has_bits_[0] &= ~0x00000800u;
}
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.V1Frame.bandwidth_upgrade_retry)
}
inline ::location::nearby::connections::BandwidthUpgradeRetryFrame* V1Frame::release_bandwidth_upgrade_retry() {
_has_bits_[0] &= ~0x00000800u;
::location::nearby::connections::BandwidthUpgradeRetryFrame* temp = bandwidth_upgrade_retry_;
bandwidth_upgrade_retry_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
if (GetArenaForAllocation() == nullptr) { delete old; }
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
if (GetArenaForAllocation() != nullptr) {
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
}
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
return temp;
}
inline ::location::nearby::connections::BandwidthUpgradeRetryFrame* V1Frame::unsafe_arena_release_bandwidth_upgrade_retry() {
// @@protoc_insertion_point(field_release:location.nearby.connections.V1Frame.bandwidth_upgrade_retry)
_has_bits_[0] &= ~0x00000800u;
::location::nearby::connections::BandwidthUpgradeRetryFrame* temp = bandwidth_upgrade_retry_;
bandwidth_upgrade_retry_ = nullptr;
return temp;
}
inline ::location::nearby::connections::BandwidthUpgradeRetryFrame* V1Frame::_internal_mutable_bandwidth_upgrade_retry() {
_has_bits_[0] |= 0x00000800u;
if (bandwidth_upgrade_retry_ == nullptr) {
auto* p = CreateMaybeMessage<::location::nearby::connections::BandwidthUpgradeRetryFrame>(GetArenaForAllocation());
bandwidth_upgrade_retry_ = p;
}
return bandwidth_upgrade_retry_;
}
inline ::location::nearby::connections::BandwidthUpgradeRetryFrame* V1Frame::mutable_bandwidth_upgrade_retry() {
::location::nearby::connections::BandwidthUpgradeRetryFrame* _msg = _internal_mutable_bandwidth_upgrade_retry();
// @@protoc_insertion_point(field_mutable:location.nearby.connections.V1Frame.bandwidth_upgrade_retry)
return _msg;
}
inline void V1Frame::set_allocated_bandwidth_upgrade_retry(::location::nearby::connections::BandwidthUpgradeRetryFrame* bandwidth_upgrade_retry) {
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
if (message_arena == nullptr) {
delete bandwidth_upgrade_retry_;
}
if (bandwidth_upgrade_retry) {
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::BandwidthUpgradeRetryFrame>::GetOwningArena(bandwidth_upgrade_retry);
if (message_arena != submessage_arena) {
bandwidth_upgrade_retry = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
message_arena, bandwidth_upgrade_retry, submessage_arena);
}
_has_bits_[0] |= 0x00000800u;
} else {
_has_bits_[0] &= ~0x00000800u;
}
bandwidth_upgrade_retry_ = bandwidth_upgrade_retry;
// @@protoc_insertion_point(field_set_allocated:location.nearby.connections.V1Frame.bandwidth_upgrade_retry)
}
// -------------------------------------------------------------------
// ConnectionRequestFrame
@@ -13263,6 +13616,83 @@ inline void BandwidthUpgradeNegotiationFrame::set_allocated_client_introduction_
// -------------------------------------------------------------------
// BandwidthUpgradeRetryFrame
// repeated .location.nearby.connections.BandwidthUpgradeRetryFrame.Medium supported_medium = 1;
inline int BandwidthUpgradeRetryFrame::_internal_supported_medium_size() const {
return supported_medium_.size();
}
inline int BandwidthUpgradeRetryFrame::supported_medium_size() const {
return _internal_supported_medium_size();
}
inline void BandwidthUpgradeRetryFrame::clear_supported_medium() {
supported_medium_.Clear();
}
inline ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::_internal_supported_medium(int index) const {
return static_cast< ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium >(supported_medium_.Get(index));
}
inline ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium BandwidthUpgradeRetryFrame::supported_medium(int index) const {
// @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium)
return _internal_supported_medium(index);
}
inline void BandwidthUpgradeRetryFrame::set_supported_medium(int index, ::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value) {
assert(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium_IsValid(value));
supported_medium_.Set(index, value);
// @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium)
}
inline void BandwidthUpgradeRetryFrame::_internal_add_supported_medium(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value) {
assert(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium_IsValid(value));
supported_medium_.Add(value);
}
inline void BandwidthUpgradeRetryFrame::add_supported_medium(::location::nearby::connections::BandwidthUpgradeRetryFrame_Medium value) {
_internal_add_supported_medium(value);
// @@protoc_insertion_point(field_add:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
BandwidthUpgradeRetryFrame::supported_medium() const {
// @@protoc_insertion_point(field_list:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium)
return supported_medium_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
BandwidthUpgradeRetryFrame::_internal_mutable_supported_medium() {
return &supported_medium_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
BandwidthUpgradeRetryFrame::mutable_supported_medium() {
// @@protoc_insertion_point(field_mutable_list:location.nearby.connections.BandwidthUpgradeRetryFrame.supported_medium)
return _internal_mutable_supported_medium();
}
// optional bool is_request = 2;
inline bool BandwidthUpgradeRetryFrame::_internal_has_is_request() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool BandwidthUpgradeRetryFrame::has_is_request() const {
return _internal_has_is_request();
}
inline void BandwidthUpgradeRetryFrame::clear_is_request() {
is_request_ = false;
_has_bits_[0] &= ~0x00000001u;
}
inline bool BandwidthUpgradeRetryFrame::_internal_is_request() const {
return is_request_;
}
inline bool BandwidthUpgradeRetryFrame::is_request() const {
// @@protoc_insertion_point(field_get:location.nearby.connections.BandwidthUpgradeRetryFrame.is_request)
return _internal_is_request();
}
inline void BandwidthUpgradeRetryFrame::_internal_set_is_request(bool value) {
_has_bits_[0] |= 0x00000001u;
is_request_ = value;
}
inline void BandwidthUpgradeRetryFrame::set_is_request(bool value) {
_internal_set_is_request(value);
// @@protoc_insertion_point(field_set:location.nearby.connections.BandwidthUpgradeRetryFrame.is_request)
}
// -------------------------------------------------------------------
// KeepAliveFrame
// optional bool ack = 1;
@@ -15666,6 +16096,8 @@ PresenceDevice::mutable_identity_type() {
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
@@ -15685,6 +16117,7 @@ template <> struct is_proto_enum< ::location::nearby::connections::PayloadTransf
template <> struct is_proto_enum< ::location::nearby::connections::PayloadTransferFrame_PacketType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::connections::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::LocationStandard_Format> : ::std::true_type {};
compiled_proto/internal/proto/analytics/connections_log.pb.cc
+189 -35
View File
@@ -20,7 +20,9 @@ namespace proto {
constexpr ConnectionsLog_ClientSession::ConnectionsLog_ClientSession(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: strategy_session_()
, duration_millis_(int64_t{0}){}
, connection_token_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, duration_millis_(int64_t{0})
, client_flow_id_(int64_t{0}){}
struct ConnectionsLog_ClientSessionDefaultTypeInternal {
constexpr ConnectionsLog_ClientSessionDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
@@ -209,7 +211,8 @@ constexpr ConnectionsLog_Payload::ConnectionsLog_Payload(
, num_chunks_(0)
, num_bytes_transferred_(int64_t{0})
, status_(0)
{}
, num_successful_auto_resume_(0){}
struct ConnectionsLog_PayloadDefaultTypeInternal {
constexpr ConnectionsLog_PayloadDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
@@ -272,6 +275,7 @@ constexpr ConnectionsLog_AdvertisingMetadata::ConnectionsLog_AdvertisingMetadata
, supports_extended_ble_advertisements_(false)
, supports_nfc_technology_(false)
, multiple_advertisement_supported_(false)
, supports_dual_band_(false)
, power_level_(-1)
{}
struct ConnectionsLog_AdvertisingMetadataDefaultTypeInternal {
@@ -424,6 +428,12 @@ class ConnectionsLog_ClientSession::_Internal {
public:
using HasBits = decltype(std::declval<ConnectionsLog_ClientSession>()._has_bits_);
static void set_has_duration_millis(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
static void set_has_client_flow_id(HasBits* has_bits) {
(*has_bits)[0] |= 4u;
}
static void set_has_connection_token(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
};
@@ -443,12 +453,29 @@ ConnectionsLog_ClientSession::ConnectionsLog_ClientSession(const ConnectionsLog_
_has_bits_(from._has_bits_),
strategy_session_(from.strategy_session_) {
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
duration_millis_ = from.duration_millis_;
connection_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_connection_token()) {
connection_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_connection_token(),
GetArenaForAllocation());
}
::memcpy(&duration_millis_, &from.duration_millis_,
static_cast<size_t>(reinterpret_cast<char*>(&client_flow_id_) -
reinterpret_cast<char*>(&duration_millis_)) + sizeof(client_flow_id_));
// @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.ClientSession)
}
inline void ConnectionsLog_ClientSession::SharedCtor() {
duration_millis_ = int64_t{0};
connection_token_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
reinterpret_cast<char*>(&duration_millis_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&client_flow_id_) -
reinterpret_cast<char*>(&duration_millis_)) + sizeof(client_flow_id_));
}
ConnectionsLog_ClientSession::~ConnectionsLog_ClientSession() {
@@ -460,6 +487,7 @@ ConnectionsLog_ClientSession::~ConnectionsLog_ClientSession() {
inline void ConnectionsLog_ClientSession::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
connection_token_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
void ConnectionsLog_ClientSession::ArenaDtor(void* object) {
@@ -479,7 +507,15 @@ void ConnectionsLog_ClientSession::Clear() {
(void) cached_has_bits;
strategy_session_.Clear();
duration_millis_ = int64_t{0};
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000001u) {
connection_token_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000006u) {
::memset(&duration_millis_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&client_flow_id_) -
reinterpret_cast<char*>(&duration_millis_)) + sizeof(client_flow_id_));
}
_has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
}
@@ -513,6 +549,24 @@ const char* ConnectionsLog_ClientSession::_InternalParse(const char* ptr, ::PROT
} else
goto handle_unusual;
continue;
// optional int64 client_flow_id = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
_Internal::set_has_client_flow_id(&has_bits);
client_flow_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional string connection_token = 4;
case 4:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
auto str = _internal_mutable_connection_token();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
@@ -545,7 +599,7 @@ uint8_t* ConnectionsLog_ClientSession::_InternalSerialize(
cached_has_bits = _has_bits_[0];
// optional int64 duration_millis = 1;
if (cached_has_bits & 0x00000001u) {
if (cached_has_bits & 0x00000002u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_duration_millis(), target);
}
@@ -558,6 +612,18 @@ uint8_t* ConnectionsLog_ClientSession::_InternalSerialize(
InternalWriteMessage(2, this->_internal_strategy_session(i), target, stream);
}
// optional int64 client_flow_id = 3;
if (cached_has_bits & 0x00000004u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_client_flow_id(), target);
}
// optional string connection_token = 4;
if (cached_has_bits & 0x00000001u) {
target = stream->WriteStringMaybeAliased(
4, this->_internal_connection_token(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
@@ -581,12 +647,26 @@ size_t ConnectionsLog_ClientSession::ByteSizeLong() const {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
}
// optional int64 duration_millis = 1;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000001u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis());
}
if (cached_has_bits & 0x00000007u) {
// optional string connection_token = 4;
if (cached_has_bits & 0x00000001u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_connection_token());
}
// optional int64 duration_millis = 1;
if (cached_has_bits & 0x00000002u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis());
}
// optional int64 client_flow_id = 3;
if (cached_has_bits & 0x00000004u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_client_flow_id());
}
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
}
@@ -608,8 +688,18 @@ void ConnectionsLog_ClientSession::MergeFrom(const ConnectionsLog_ClientSession&
(void) cached_has_bits;
strategy_session_.MergeFrom(from.strategy_session_);
if (from._internal_has_duration_millis()) {
_internal_set_duration_millis(from._internal_duration_millis());
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x00000007u) {
if (cached_has_bits & 0x00000001u) {
_internal_set_connection_token(from._internal_connection_token());
}
if (cached_has_bits & 0x00000002u) {
duration_millis_ = from.duration_millis_;
}
if (cached_has_bits & 0x00000004u) {
client_flow_id_ = from.client_flow_id_;
}
_has_bits_[0] |= cached_has_bits;
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
@@ -627,10 +717,22 @@ bool ConnectionsLog_ClientSession::IsInitialized() const {
void ConnectionsLog_ClientSession::InternalSwap(ConnectionsLog_ClientSession* 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]);
strategy_session_.InternalSwap(&other->strategy_session_);
swap(duration_millis_, other->duration_millis_);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&connection_token_, lhs_arena,
&other->connection_token_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(ConnectionsLog_ClientSession, client_flow_id_)
+ sizeof(ConnectionsLog_ClientSession::client_flow_id_)
- PROTOBUF_FIELD_OFFSET(ConnectionsLog_ClientSession, duration_millis_)>(
reinterpret_cast<char*>(&duration_millis_),
reinterpret_cast<char*>(&other->duration_millis_));
}
std::string ConnectionsLog_ClientSession::GetTypeName() const {
@@ -4181,6 +4283,9 @@ class ConnectionsLog_Payload::_Internal {
static void set_has_status(HasBits* has_bits) {
(*has_bits)[0] |= 32u;
}
static void set_has_num_successful_auto_resume(HasBits* has_bits) {
(*has_bits)[0] |= 64u;
}
};
ConnectionsLog_Payload::ConnectionsLog_Payload(::PROTOBUF_NAMESPACE_ID::Arena* arena,
@@ -4197,16 +4302,16 @@ ConnectionsLog_Payload::ConnectionsLog_Payload(const ConnectionsLog_Payload& fro
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
::memcpy(&duration_millis_, &from.duration_millis_,
static_cast<size_t>(reinterpret_cast<char*>(&status_) -
reinterpret_cast<char*>(&duration_millis_)) + sizeof(status_));
static_cast<size_t>(reinterpret_cast<char*>(&num_successful_auto_resume_) -
reinterpret_cast<char*>(&duration_millis_)) + sizeof(num_successful_auto_resume_));
// @@protoc_insertion_point(copy_constructor:location.nearby.analytics.proto.ConnectionsLog.Payload)
}
inline void ConnectionsLog_Payload::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
reinterpret_cast<char*>(&duration_millis_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&status_) -
reinterpret_cast<char*>(&duration_millis_)) + sizeof(status_));
0, static_cast<size_t>(reinterpret_cast<char*>(&num_successful_auto_resume_) -
reinterpret_cast<char*>(&duration_millis_)) + sizeof(num_successful_auto_resume_));
}
ConnectionsLog_Payload::~ConnectionsLog_Payload() {
@@ -4237,10 +4342,10 @@ void ConnectionsLog_Payload::Clear() {
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x0000003fu) {
if (cached_has_bits & 0x0000007fu) {
::memset(&duration_millis_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&status_) -
reinterpret_cast<char*>(&duration_millis_)) + sizeof(status_));
reinterpret_cast<char*>(&num_successful_auto_resume_) -
reinterpret_cast<char*>(&duration_millis_)) + sizeof(num_successful_auto_resume_));
}
_has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
@@ -4315,6 +4420,15 @@ const char* ConnectionsLog_Payload::_InternalParse(const char* ptr, ::PROTOBUF_N
} else
goto handle_unusual;
continue;
// optional int32 num_successful_auto_resume = 7;
case 7:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
_Internal::set_has_num_successful_auto_resume(&has_bits);
num_successful_auto_resume_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
@@ -4384,6 +4498,12 @@ uint8_t* ConnectionsLog_Payload::_InternalSerialize(
6, this->_internal_status(), target);
}
// optional int32 num_successful_auto_resume = 7;
if (cached_has_bits & 0x00000040u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_num_successful_auto_resume(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
@@ -4401,7 +4521,7 @@ size_t ConnectionsLog_Payload::ByteSizeLong() const {
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x0000003fu) {
if (cached_has_bits & 0x0000007fu) {
// optional int64 duration_millis = 1;
if (cached_has_bits & 0x00000001u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_duration_millis());
@@ -4434,6 +4554,11 @@ size_t ConnectionsLog_Payload::ByteSizeLong() const {
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status());
}
// optional int32 num_successful_auto_resume = 7;
if (cached_has_bits & 0x00000040u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_num_successful_auto_resume());
}
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
@@ -4456,7 +4581,7 @@ void ConnectionsLog_Payload::MergeFrom(const ConnectionsLog_Payload& from) {
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x0000003fu) {
if (cached_has_bits & 0x0000007fu) {
if (cached_has_bits & 0x00000001u) {
duration_millis_ = from.duration_millis_;
}
@@ -4475,6 +4600,9 @@ void ConnectionsLog_Payload::MergeFrom(const ConnectionsLog_Payload& from) {
if (cached_has_bits & 0x00000020u) {
status_ = from.status_;
}
if (cached_has_bits & 0x00000040u) {
num_successful_auto_resume_ = from.num_successful_auto_resume_;
}
_has_bits_[0] |= cached_has_bits;
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
@@ -4496,8 +4624,8 @@ void ConnectionsLog_Payload::InternalSwap(ConnectionsLog_Payload* other) {
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(ConnectionsLog_Payload, status_)
+ sizeof(ConnectionsLog_Payload::status_)
PROTOBUF_FIELD_OFFSET(ConnectionsLog_Payload, num_successful_auto_resume_)
+ sizeof(ConnectionsLog_Payload::num_successful_auto_resume_)
- PROTOBUF_FIELD_OFFSET(ConnectionsLog_Payload, duration_millis_)>(
reinterpret_cast<char*>(&duration_millis_),
reinterpret_cast<char*>(&other->duration_millis_));
@@ -5967,6 +6095,9 @@ class ConnectionsLog_AdvertisingMetadata::_Internal {
(*has_bits)[0] |= 8u;
}
static void set_has_power_level(HasBits* has_bits) {
(*has_bits)[0] |= 32u;
}
static void set_has_supports_dual_band(HasBits* has_bits) {
(*has_bits)[0] |= 16u;
}
};
@@ -5993,8 +6124,8 @@ ConnectionsLog_AdvertisingMetadata::ConnectionsLog_AdvertisingMetadata(const Con
inline void ConnectionsLog_AdvertisingMetadata::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
reinterpret_cast<char*>(&connected_ap_frequency_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&multiple_advertisement_supported_) -
reinterpret_cast<char*>(&connected_ap_frequency_)) + sizeof(multiple_advertisement_supported_));
0, static_cast<size_t>(reinterpret_cast<char*>(&supports_dual_band_) -
reinterpret_cast<char*>(&connected_ap_frequency_)) + sizeof(supports_dual_band_));
power_level_ = -1;
}
@@ -6026,10 +6157,10 @@ void ConnectionsLog_AdvertisingMetadata::Clear() {
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x0000001fu) {
if (cached_has_bits & 0x0000003fu) {
::memset(&connected_ap_frequency_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&multiple_advertisement_supported_) -
reinterpret_cast<char*>(&connected_ap_frequency_)) + sizeof(multiple_advertisement_supported_));
reinterpret_cast<char*>(&supports_dual_band_) -
reinterpret_cast<char*>(&connected_ap_frequency_)) + sizeof(supports_dual_band_));
power_level_ = -1;
}
_has_bits_.Clear();
@@ -6092,6 +6223,15 @@ const char* ConnectionsLog_AdvertisingMetadata::_InternalParse(const char* ptr,
} else
goto handle_unusual;
continue;
// optional bool supports_dual_band = 6;
case 6:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
_Internal::set_has_supports_dual_band(&has_bits);
supports_dual_band_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
@@ -6148,12 +6288,18 @@ uint8_t* ConnectionsLog_AdvertisingMetadata::_InternalSerialize(
}
// optional .location.nearby.proto.connections.PowerLevel power_level = 5;
if (cached_has_bits & 0x00000010u) {
if (cached_has_bits & 0x00000020u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
5, this->_internal_power_level(), target);
}
// optional bool supports_dual_band = 6;
if (cached_has_bits & 0x00000010u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(6, this->_internal_supports_dual_band(), target);
}
if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
@@ -6171,7 +6317,7 @@ size_t ConnectionsLog_AdvertisingMetadata::ByteSizeLong() const {
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x0000001fu) {
if (cached_has_bits & 0x0000003fu) {
// optional int32 connected_ap_frequency = 2;
if (cached_has_bits & 0x00000001u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_connected_ap_frequency());
@@ -6192,8 +6338,13 @@ size_t ConnectionsLog_AdvertisingMetadata::ByteSizeLong() const {
total_size += 1 + 1;
}
// optional .location.nearby.proto.connections.PowerLevel power_level = 5;
// optional bool supports_dual_band = 6;
if (cached_has_bits & 0x00000010u) {
total_size += 1 + 1;
}
// optional .location.nearby.proto.connections.PowerLevel power_level = 5;
if (cached_has_bits & 0x00000020u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_power_level());
}
@@ -6220,7 +6371,7 @@ void ConnectionsLog_AdvertisingMetadata::MergeFrom(const ConnectionsLog_Advertis
(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) {
connected_ap_frequency_ = from.connected_ap_frequency_;
}
@@ -6234,6 +6385,9 @@ void ConnectionsLog_AdvertisingMetadata::MergeFrom(const ConnectionsLog_Advertis
multiple_advertisement_supported_ = from.multiple_advertisement_supported_;
}
if (cached_has_bits & 0x00000010u) {
supports_dual_band_ = from.supports_dual_band_;
}
if (cached_has_bits & 0x00000020u) {
power_level_ = from.power_level_;
}
_has_bits_[0] |= cached_has_bits;
@@ -6257,8 +6411,8 @@ void ConnectionsLog_AdvertisingMetadata::InternalSwap(ConnectionsLog_Advertising
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(ConnectionsLog_AdvertisingMetadata, multiple_advertisement_supported_)
+ sizeof(ConnectionsLog_AdvertisingMetadata::multiple_advertisement_supported_)
PROTOBUF_FIELD_OFFSET(ConnectionsLog_AdvertisingMetadata, supports_dual_band_)
+ sizeof(ConnectionsLog_AdvertisingMetadata::supports_dual_band_)
- PROTOBUF_FIELD_OFFSET(ConnectionsLog_AdvertisingMetadata, connected_ap_frequency_)>(
reinterpret_cast<char*>(&connected_ap_frequency_),
reinterpret_cast<char*>(&other->connected_ap_frequency_));
compiled_proto/internal/proto/analytics/connections_log.pb.h
+224 -6
View File
@@ -272,7 +272,9 @@ class ConnectionsLog_ClientSession final :
enum : int {
kStrategySessionFieldNumber = 2,
kConnectionTokenFieldNumber = 4,
kDurationMillisFieldNumber = 1,
kClientFlowIdFieldNumber = 3,
};
// repeated .location.nearby.analytics.proto.ConnectionsLog.StrategySession strategy_session = 2;
int strategy_session_size() const;
@@ -292,6 +294,24 @@ class ConnectionsLog_ClientSession final :
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::location::nearby::analytics::proto::ConnectionsLog_StrategySession >&
strategy_session() const;
// optional string connection_token = 4;
bool has_connection_token() const;
private:
bool _internal_has_connection_token() const;
public:
void clear_connection_token();
const std::string& connection_token() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_connection_token(ArgT0&& arg0, ArgT... args);
std::string* mutable_connection_token();
PROTOBUF_NODISCARD std::string* release_connection_token();
void set_allocated_connection_token(std::string* connection_token);
private:
const std::string& _internal_connection_token() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_connection_token(const std::string& value);
std::string* _internal_mutable_connection_token();
public:
// optional int64 duration_millis = 1;
bool has_duration_millis() const;
private:
@@ -305,6 +325,19 @@ class ConnectionsLog_ClientSession final :
void _internal_set_duration_millis(int64_t value);
public:
// optional int64 client_flow_id = 3;
bool has_client_flow_id() const;
private:
bool _internal_has_client_flow_id() const;
public:
void clear_client_flow_id();
int64_t client_flow_id() const;
void set_client_flow_id(int64_t value);
private:
int64_t _internal_client_flow_id() const;
void _internal_set_client_flow_id(int64_t value);
public:
// @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.ClientSession)
private:
class _Internal;
@@ -315,7 +348,9 @@ class ConnectionsLog_ClientSession final :
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::location::nearby::analytics::proto::ConnectionsLog_StrategySession > strategy_session_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr connection_token_;
int64_t duration_millis_;
int64_t client_flow_id_;
friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto;
};
// -------------------------------------------------------------------
@@ -2597,6 +2632,7 @@ class ConnectionsLog_Payload final :
kNumChunksFieldNumber = 5,
kNumBytesTransferredFieldNumber = 4,
kStatusFieldNumber = 6,
kNumSuccessfulAutoResumeFieldNumber = 7,
};
// optional int64 duration_millis = 1;
bool has_duration_millis() const;
@@ -2676,6 +2712,19 @@ class ConnectionsLog_Payload final :
void _internal_set_status(::location::nearby::proto::connections::PayloadStatus value);
public:
// optional int32 num_successful_auto_resume = 7;
bool has_num_successful_auto_resume() const;
private:
bool _internal_has_num_successful_auto_resume() const;
public:
void clear_num_successful_auto_resume();
int32_t num_successful_auto_resume() const;
void set_num_successful_auto_resume(int32_t value);
private:
int32_t _internal_num_successful_auto_resume() const;
void _internal_set_num_successful_auto_resume(int32_t value);
public:
// @@protoc_insertion_point(class_scope:location.nearby.analytics.proto.ConnectionsLog.Payload)
private:
class _Internal;
@@ -2691,6 +2740,7 @@ class ConnectionsLog_Payload final :
int32_t num_chunks_;
int64_t num_bytes_transferred_;
int status_;
int32_t num_successful_auto_resume_;
friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto;
};
// -------------------------------------------------------------------
@@ -3559,6 +3609,7 @@ class ConnectionsLog_AdvertisingMetadata final :
kSupportsExtendedBleAdvertisementsFieldNumber = 1,
kSupportsNfcTechnologyFieldNumber = 3,
kMultipleAdvertisementSupportedFieldNumber = 4,
kSupportsDualBandFieldNumber = 6,
kPowerLevelFieldNumber = 5,
};
// optional int32 connected_ap_frequency = 2;
@@ -3613,6 +3664,19 @@ class ConnectionsLog_AdvertisingMetadata final :
void _internal_set_multiple_advertisement_supported(bool value);
public:
// optional bool supports_dual_band = 6;
bool has_supports_dual_band() const;
private:
bool _internal_has_supports_dual_band() const;
public:
void clear_supports_dual_band();
bool supports_dual_band() const;
void set_supports_dual_band(bool value);
private:
bool _internal_supports_dual_band() const;
void _internal_set_supports_dual_band(bool value);
public:
// optional .location.nearby.proto.connections.PowerLevel power_level = 5;
bool has_power_level() const;
private:
@@ -3639,6 +3703,7 @@ class ConnectionsLog_AdvertisingMetadata final :
bool supports_extended_ble_advertisements_;
bool supports_nfc_technology_;
bool multiple_advertisement_supported_;
bool supports_dual_band_;
int power_level_;
friend struct ::TableStruct_internal_2fproto_2fanalytics_2fconnections_5flog_2eproto;
};
@@ -4458,7 +4523,7 @@ class ConnectionsLog final :
// optional int64 duration_millis = 1;
inline bool ConnectionsLog_ClientSession::_internal_has_duration_millis() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool ConnectionsLog_ClientSession::has_duration_millis() const {
@@ -4466,7 +4531,7 @@ inline bool ConnectionsLog_ClientSession::has_duration_millis() const {
}
inline void ConnectionsLog_ClientSession::clear_duration_millis() {
duration_millis_ = int64_t{0};
_has_bits_[0] &= ~0x00000001u;
_has_bits_[0] &= ~0x00000002u;
}
inline int64_t ConnectionsLog_ClientSession::_internal_duration_millis() const {
return duration_millis_;
@@ -4476,7 +4541,7 @@ inline int64_t ConnectionsLog_ClientSession::duration_millis() const {
return _internal_duration_millis();
}
inline void ConnectionsLog_ClientSession::_internal_set_duration_millis(int64_t value) {
_has_bits_[0] |= 0x00000001u;
_has_bits_[0] |= 0x00000002u;
duration_millis_ = value;
}
inline void ConnectionsLog_ClientSession::set_duration_millis(int64_t value) {
@@ -4524,6 +4589,103 @@ ConnectionsLog_ClientSession::strategy_session() const {
return strategy_session_;
}
// optional int64 client_flow_id = 3;
inline bool ConnectionsLog_ClientSession::_internal_has_client_flow_id() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool ConnectionsLog_ClientSession::has_client_flow_id() const {
return _internal_has_client_flow_id();
}
inline void ConnectionsLog_ClientSession::clear_client_flow_id() {
client_flow_id_ = int64_t{0};
_has_bits_[0] &= ~0x00000004u;
}
inline int64_t ConnectionsLog_ClientSession::_internal_client_flow_id() const {
return client_flow_id_;
}
inline int64_t ConnectionsLog_ClientSession::client_flow_id() const {
// @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.ClientSession.client_flow_id)
return _internal_client_flow_id();
}
inline void ConnectionsLog_ClientSession::_internal_set_client_flow_id(int64_t value) {
_has_bits_[0] |= 0x00000004u;
client_flow_id_ = value;
}
inline void ConnectionsLog_ClientSession::set_client_flow_id(int64_t value) {
_internal_set_client_flow_id(value);
// @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.ClientSession.client_flow_id)
}
// optional string connection_token = 4;
inline bool ConnectionsLog_ClientSession::_internal_has_connection_token() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool ConnectionsLog_ClientSession::has_connection_token() const {
return _internal_has_connection_token();
}
inline void ConnectionsLog_ClientSession::clear_connection_token() {
connection_token_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& ConnectionsLog_ClientSession::connection_token() const {
// @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token)
return _internal_connection_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ConnectionsLog_ClientSession::set_connection_token(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
connection_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token)
}
inline std::string* ConnectionsLog_ClientSession::mutable_connection_token() {
std::string* _s = _internal_mutable_connection_token();
// @@protoc_insertion_point(field_mutable:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token)
return _s;
}
inline const std::string& ConnectionsLog_ClientSession::_internal_connection_token() const {
return connection_token_.Get();
}
inline void ConnectionsLog_ClientSession::_internal_set_connection_token(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
connection_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ConnectionsLog_ClientSession::_internal_mutable_connection_token() {
_has_bits_[0] |= 0x00000001u;
return connection_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ConnectionsLog_ClientSession::release_connection_token() {
// @@protoc_insertion_point(field_release:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token)
if (!_internal_has_connection_token()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = connection_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (connection_token_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void ConnectionsLog_ClientSession::set_allocated_connection_token(std::string* connection_token) {
if (connection_token != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
connection_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), connection_token,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (connection_token_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
connection_token_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:location.nearby.analytics.proto.ConnectionsLog.ClientSession.connection_token)
}
// -------------------------------------------------------------------
// ConnectionsLog_StrategySession
@@ -6902,6 +7064,34 @@ inline void ConnectionsLog_Payload::set_status(::location::nearby::proto::connec
// @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.Payload.status)
}
// optional int32 num_successful_auto_resume = 7;
inline bool ConnectionsLog_Payload::_internal_has_num_successful_auto_resume() const {
bool value = (_has_bits_[0] & 0x00000040u) != 0;
return value;
}
inline bool ConnectionsLog_Payload::has_num_successful_auto_resume() const {
return _internal_has_num_successful_auto_resume();
}
inline void ConnectionsLog_Payload::clear_num_successful_auto_resume() {
num_successful_auto_resume_ = 0;
_has_bits_[0] &= ~0x00000040u;
}
inline int32_t ConnectionsLog_Payload::_internal_num_successful_auto_resume() const {
return num_successful_auto_resume_;
}
inline int32_t ConnectionsLog_Payload::num_successful_auto_resume() const {
// @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.Payload.num_successful_auto_resume)
return _internal_num_successful_auto_resume();
}
inline void ConnectionsLog_Payload::_internal_set_num_successful_auto_resume(int32_t value) {
_has_bits_[0] |= 0x00000040u;
num_successful_auto_resume_ = value;
}
inline void ConnectionsLog_Payload::set_num_successful_auto_resume(int32_t value) {
_internal_set_num_successful_auto_resume(value);
// @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.Payload.num_successful_auto_resume)
}
// -------------------------------------------------------------------
// ConnectionsLog_BandwidthUpgradeAttempt
@@ -8135,7 +8325,7 @@ inline void ConnectionsLog_AdvertisingMetadata::set_multiple_advertisement_suppo
// optional .location.nearby.proto.connections.PowerLevel power_level = 5;
inline bool ConnectionsLog_AdvertisingMetadata::_internal_has_power_level() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
bool value = (_has_bits_[0] & 0x00000020u) != 0;
return value;
}
inline bool ConnectionsLog_AdvertisingMetadata::has_power_level() const {
@@ -8143,7 +8333,7 @@ inline bool ConnectionsLog_AdvertisingMetadata::has_power_level() const {
}
inline void ConnectionsLog_AdvertisingMetadata::clear_power_level() {
power_level_ = -1;
_has_bits_[0] &= ~0x00000010u;
_has_bits_[0] &= ~0x00000020u;
}
inline ::location::nearby::proto::connections::PowerLevel ConnectionsLog_AdvertisingMetadata::_internal_power_level() const {
return static_cast< ::location::nearby::proto::connections::PowerLevel >(power_level_);
@@ -8154,7 +8344,7 @@ inline ::location::nearby::proto::connections::PowerLevel ConnectionsLog_Adverti
}
inline void ConnectionsLog_AdvertisingMetadata::_internal_set_power_level(::location::nearby::proto::connections::PowerLevel value) {
assert(::location::nearby::proto::connections::PowerLevel_IsValid(value));
_has_bits_[0] |= 0x00000010u;
_has_bits_[0] |= 0x00000020u;
power_level_ = value;
}
inline void ConnectionsLog_AdvertisingMetadata::set_power_level(::location::nearby::proto::connections::PowerLevel value) {
@@ -8162,6 +8352,34 @@ inline void ConnectionsLog_AdvertisingMetadata::set_power_level(::location::near
// @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.AdvertisingMetadata.power_level)
}
// optional bool supports_dual_band = 6;
inline bool ConnectionsLog_AdvertisingMetadata::_internal_has_supports_dual_band() const {
bool value = (_has_bits_[0] & 0x00000010u) != 0;
return value;
}
inline bool ConnectionsLog_AdvertisingMetadata::has_supports_dual_band() const {
return _internal_has_supports_dual_band();
}
inline void ConnectionsLog_AdvertisingMetadata::clear_supports_dual_band() {
supports_dual_band_ = false;
_has_bits_[0] &= ~0x00000010u;
}
inline bool ConnectionsLog_AdvertisingMetadata::_internal_supports_dual_band() const {
return supports_dual_band_;
}
inline bool ConnectionsLog_AdvertisingMetadata::supports_dual_band() const {
// @@protoc_insertion_point(field_get:location.nearby.analytics.proto.ConnectionsLog.AdvertisingMetadata.supports_dual_band)
return _internal_supports_dual_band();
}
inline void ConnectionsLog_AdvertisingMetadata::_internal_set_supports_dual_band(bool value) {
_has_bits_[0] |= 0x00000010u;
supports_dual_band_ = value;
}
inline void ConnectionsLog_AdvertisingMetadata::set_supports_dual_band(bool value) {
_internal_set_supports_dual_band(value);
// @@protoc_insertion_point(field_set:location.nearby.analytics.proto.ConnectionsLog.AdvertisingMetadata.supports_dual_band)
}
// -------------------------------------------------------------------
// ConnectionsLog_DiscoveryMetadata
compiled_proto/proto/connections_enums.pb.cc
+472 -460
View File
File diff suppressed because it is too large Load Diff
compiled_proto/proto/connections_enums.pb.h
+19 -16
View File
@@ -299,11 +299,12 @@ enum DisconnectionReason : int {
UPGRADED = 4,
SHUTDOWN = 5,
UNFINISHED = 6,
PREV_CHANNEL_DISCONNECTION_IN_RECONNECT = 7
PREV_CHANNEL_DISCONNECTION_IN_RECONNECT = 7,
AUTHENTICATION_FAILURE = 8
};
bool DisconnectionReason_IsValid(int value);
constexpr DisconnectionReason DisconnectionReason_MIN = UNKNOWN_DISCONNECTION_REASON;
constexpr DisconnectionReason DisconnectionReason_MAX = PREV_CHANNEL_DISCONNECTION_IN_RECONNECT;
constexpr DisconnectionReason DisconnectionReason_MAX = AUTHENTICATION_FAILURE;
constexpr int DisconnectionReason_ARRAYSIZE = DisconnectionReason_MAX + 1;
const std::string& DisconnectionReason_Name(DisconnectionReason value);
@@ -546,7 +547,7 @@ inline const std::string& OperationResultCategory_Name(T enum_t_value) {
}
bool OperationResultCategory_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultCategory* value);
enum OperationResultDetail : int {
enum OperationResultCode : int {
DETAIL_UNKNOWN = 0,
DETAIL_SUCCESS = 1,
CLIENT_CANCELLATION_REMOTE_IN_CANCELED_STATE = 500,
@@ -653,7 +654,7 @@ enum OperationResultDetail : int {
IO_FOLDER_CREATION_ERROR = 3003,
IO_STREAM_CREATE_PIPE_FAILURE = 3004,
IO_ENDPOINT_IO_ERROR_ON_BLE = 3005,
IO_ENDPOINT_IO_ERROR_ON_L2CAP = 3006,
IO_ENDPOINT_IO_ERROR_ON_BLE_L2CAP = 3006,
IO_ENDPOINT_IO_ERROR_ON_BT = 3007,
IO_ENDPOINT_IO_ERROR_ON_WEB_RTC = 3008,
IO_ENDPOINT_IO_ERROR_ON_LAN = 3009,
@@ -718,6 +719,8 @@ enum OperationResultDetail : int {
CONNECTIVITY_GENERIC_PAYLOAD_SENT_ERROR = 3553,
CONNECTIVITY_L2CAP_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE = 3554,
CONNECTIVITY_BT_SERVER_SOCKET_CREATION_SECURITY_EXCEPTION_FAILURE = 3555,
CONNECTIVITY_L2CAP_CLIENT_SOCKET_CREATION_TIMEOUT_FAILURE = 3556,
CONNECTIVITY_WEB_RTC_UNSATISFIED_LINK_ERROR = 3557,
NEARBY_BLE_ADVERTISEMENT_MAPPING_TO_MAC_ERROR = 4500,
NEARBY_BLUETOOTH_MAC_ADDRESS_INVALID_FOR_CONNECT = 4501,
NEARBY_WEB_RTC_CONNECTION_FLOW_NULL = 4502,
@@ -786,21 +789,21 @@ enum OperationResultDetail : int {
NEARBY_WIFI_LAN_IP_ADDRESS_ERROR = 4565,
NEARBY_L2CAP_PSM_NOT_POSITIVE = 4566
};
bool OperationResultDetail_IsValid(int value);
constexpr OperationResultDetail OperationResultDetail_MIN = DETAIL_UNKNOWN;
constexpr OperationResultDetail OperationResultDetail_MAX = NEARBY_L2CAP_PSM_NOT_POSITIVE;
constexpr int OperationResultDetail_ARRAYSIZE = OperationResultDetail_MAX + 1;
bool OperationResultCode_IsValid(int value);
constexpr OperationResultCode OperationResultCode_MIN = DETAIL_UNKNOWN;
constexpr OperationResultCode OperationResultCode_MAX = NEARBY_L2CAP_PSM_NOT_POSITIVE;
constexpr int OperationResultCode_ARRAYSIZE = OperationResultCode_MAX + 1;
const std::string& OperationResultDetail_Name(OperationResultDetail value);
const std::string& OperationResultCode_Name(OperationResultCode value);
template<typename T>
inline const std::string& OperationResultDetail_Name(T enum_t_value) {
static_assert(::std::is_same<T, OperationResultDetail>::value ||
inline const std::string& OperationResultCode_Name(T enum_t_value) {
static_assert(::std::is_same<T, OperationResultCode>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function OperationResultDetail_Name.");
return OperationResultDetail_Name(static_cast<OperationResultDetail>(enum_t_value));
"Incorrect type passed to function OperationResultCode_Name.");
return OperationResultCode_Name(static_cast<OperationResultCode>(enum_t_value));
}
bool OperationResultDetail_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultDetail* value);
bool OperationResultCode_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OperationResultCode* value);
// ===================================================================
@@ -845,7 +848,7 @@ template <> struct is_proto_enum< ::location::nearby::proto::connections::Bandwi
template <> struct is_proto_enum< ::location::nearby::proto::connections::LogSource> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::PowerLevel> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::OperationResultCategory> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::OperationResultDetail> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::OperationResultCode> : ::std::true_type {};
PROTOBUF_NAMESPACE_CLOSE