From 7559639ef2c33d3c62dabbb09ca9f04c70c08908 Mon Sep 17 00:00:00 2001 From: edwinwugoog Date: Tue, 14 Feb 2023 14:41:04 +0800 Subject: [PATCH] Compile protos --- .../proto/offline_wire_formats.pb.cc | 368 +++++++++++++++++- .../proto/offline_wire_formats.pb.h | 363 ++++++++++++++++- 2 files changed, 707 insertions(+), 24 deletions(-) diff --git a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc index ccb71db7..1b0fa4a5 100644 --- a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc +++ b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.cc @@ -75,6 +75,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionRequestFrameDefaultTy constexpr ConnectionResponseFrame::ConnectionResponseFrame( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : handshake_data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , os_info_(nullptr) , status_(0) , response_(0) {} @@ -442,6 +443,19 @@ struct LocationStandardDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LocationStandardDefaultTypeInternal _LocationStandard_default_instance_; +constexpr OsInfo::OsInfo( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(0) +{} +struct OsInfoDefaultTypeInternal { + constexpr OsInfoDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~OsInfoDefaultTypeInternal() {} + union { + OsInfo _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OsInfoDefaultTypeInternal _OsInfo_default_instance_; } // namespace connections } // namespace nearby } // namespace location @@ -1261,6 +1275,84 @@ constexpr LocationStandard_Format LocationStandard::Format_MIN; constexpr LocationStandard_Format LocationStandard::Format_MAX; constexpr int LocationStandard::Format_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +bool OsInfo_OsType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 100: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed OsInfo_OsType_strings[6] = {}; + +static const char OsInfo_OsType_names[] = + "ANDROID" + "APPLE" + "CHROME_OS" + "LINUX" + "UNKNOWN_OS_TYPE" + "WINDOWS"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OsInfo_OsType_entries[] = { + { {OsInfo_OsType_names + 0, 7}, 1 }, + { {OsInfo_OsType_names + 7, 5}, 4 }, + { {OsInfo_OsType_names + 12, 9}, 2 }, + { {OsInfo_OsType_names + 21, 5}, 100 }, + { {OsInfo_OsType_names + 26, 15}, 0 }, + { {OsInfo_OsType_names + 41, 7}, 3 }, +}; + +static const int OsInfo_OsType_entries_by_number[] = { + 4, // 0 -> UNKNOWN_OS_TYPE + 0, // 1 -> ANDROID + 2, // 2 -> CHROME_OS + 5, // 3 -> WINDOWS + 1, // 4 -> APPLE + 3, // 100 -> LINUX +}; + +const std::string& OsInfo_OsType_Name( + OsInfo_OsType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + OsInfo_OsType_entries, + OsInfo_OsType_entries_by_number, + 6, OsInfo_OsType_strings); + (void) dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + OsInfo_OsType_entries, + OsInfo_OsType_entries_by_number, + 6, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : + OsInfo_OsType_strings[idx].get(); +} +bool OsInfo_OsType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OsInfo_OsType* value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + OsInfo_OsType_entries, 6, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr OsInfo_OsType OsInfo::UNKNOWN_OS_TYPE; +constexpr OsInfo_OsType OsInfo::ANDROID; +constexpr OsInfo_OsType OsInfo::CHROME_OS; +constexpr OsInfo_OsType OsInfo::WINDOWS; +constexpr OsInfo_OsType OsInfo::APPLE; +constexpr OsInfo_OsType OsInfo::LINUX; +constexpr OsInfo_OsType OsInfo::OsType_MIN; +constexpr OsInfo_OsType OsInfo::OsType_MAX; +constexpr int OsInfo::OsType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) // =================================================================== @@ -2670,16 +2762,24 @@ class ConnectionResponseFrame::_Internal { public: using HasBits = decltype(std::declval()._has_bits_); static void set_has_status(HasBits* has_bits) { - (*has_bits)[0] |= 2u; + (*has_bits)[0] |= 4u; } static void set_has_handshake_data(HasBits* has_bits) { (*has_bits)[0] |= 1u; } static void set_has_response(HasBits* has_bits) { - (*has_bits)[0] |= 4u; + (*has_bits)[0] |= 8u; + } + static const ::location::nearby::connections::OsInfo& os_info(const ConnectionResponseFrame* msg); + static void set_has_os_info(HasBits* has_bits) { + (*has_bits)[0] |= 2u; } }; +const ::location::nearby::connections::OsInfo& +ConnectionResponseFrame::_Internal::os_info(const ConnectionResponseFrame* msg) { + return *msg->os_info_; +} ConnectionResponseFrame::ConnectionResponseFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { @@ -2701,6 +2801,11 @@ ConnectionResponseFrame::ConnectionResponseFrame(const ConnectionResponseFrame& handshake_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_handshake_data(), GetArenaForAllocation()); } + if (from._internal_has_os_info()) { + os_info_ = new ::location::nearby::connections::OsInfo(*from.os_info_); + } else { + os_info_ = nullptr; + } ::memcpy(&status_, &from.status_, static_cast(reinterpret_cast(&response_) - reinterpret_cast(&status_)) + sizeof(response_)); @@ -2713,9 +2818,9 @@ handshake_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStr handshake_data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&status_) - reinterpret_cast(this)), + reinterpret_cast(&os_info_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&response_) - - reinterpret_cast(&status_)) + sizeof(response_)); + reinterpret_cast(&os_info_)) + sizeof(response_)); } ConnectionResponseFrame::~ConnectionResponseFrame() { @@ -2728,6 +2833,7 @@ ConnectionResponseFrame::~ConnectionResponseFrame() { inline void ConnectionResponseFrame::SharedDtor() { GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); handshake_data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete os_info_; } void ConnectionResponseFrame::ArenaDtor(void* object) { @@ -2747,10 +2853,16 @@ void ConnectionResponseFrame::Clear() { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000001u) { - handshake_data_.ClearNonDefaultToEmpty(); + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + handshake_data_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(os_info_ != nullptr); + os_info_->Clear(); + } } - if (cached_has_bits & 0x00000006u) { + if (cached_has_bits & 0x0000000cu) { ::memset(&status_, 0, static_cast( reinterpret_cast(&response_) - reinterpret_cast(&status_)) + sizeof(response_)); @@ -2797,6 +2909,14 @@ const char* ConnectionResponseFrame::_InternalParse(const char* ptr, ::PROTOBUF_ } else goto handle_unusual; continue; + // optional .location.nearby.connections.OsInfo os_info = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_os_info(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -2829,7 +2949,7 @@ uint8_t* ConnectionResponseFrame::_InternalSerialize( cached_has_bits = _has_bits_[0]; // optional int32 status = 1 [deprecated = true]; - if (cached_has_bits & 0x00000002u) { + if (cached_has_bits & 0x00000004u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_status(), target); } @@ -2841,12 +2961,20 @@ uint8_t* ConnectionResponseFrame::_InternalSerialize( } // optional .location.nearby.connections.ConnectionResponseFrame.ResponseStatus response = 3; - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_response(), target); } + // optional .location.nearby.connections.OsInfo os_info = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::os_info(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); @@ -2864,7 +2992,7 @@ size_t ConnectionResponseFrame::ByteSizeLong() const { (void) cached_has_bits; cached_has_bits = _has_bits_[0]; - if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x0000000fu) { // optional bytes handshake_data = 2; if (cached_has_bits & 0x00000001u) { total_size += 1 + @@ -2872,13 +3000,20 @@ size_t ConnectionResponseFrame::ByteSizeLong() const { this->_internal_handshake_data()); } - // optional int32 status = 1 [deprecated = true]; + // optional .location.nearby.connections.OsInfo os_info = 4; if (cached_has_bits & 0x00000002u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *os_info_); + } + + // optional int32 status = 1 [deprecated = true]; + if (cached_has_bits & 0x00000004u) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_status()); } // optional .location.nearby.connections.ConnectionResponseFrame.ResponseStatus response = 3; - if (cached_has_bits & 0x00000004u) { + if (cached_has_bits & 0x00000008u) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_response()); } @@ -2905,14 +3040,17 @@ void ConnectionResponseFrame::MergeFrom(const ConnectionResponseFrame& from) { (void) cached_has_bits; cached_has_bits = from._has_bits_[0]; - if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x0000000fu) { if (cached_has_bits & 0x00000001u) { _internal_set_handshake_data(from._internal_handshake_data()); } if (cached_has_bits & 0x00000002u) { - status_ = from.status_; + _internal_mutable_os_info()->::location::nearby::connections::OsInfo::MergeFrom(from._internal_os_info()); } if (cached_has_bits & 0x00000004u) { + status_ = from.status_; + } + if (cached_has_bits & 0x00000008u) { response_ = from.response_; } _has_bits_[0] |= cached_has_bits; @@ -2945,9 +3083,9 @@ void ConnectionResponseFrame::InternalSwap(ConnectionResponseFrame* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ConnectionResponseFrame, response_) + sizeof(ConnectionResponseFrame::response_) - - PROTOBUF_FIELD_OFFSET(ConnectionResponseFrame, status_)>( - reinterpret_cast(&status_), - reinterpret_cast(&other->status_)); + - PROTOBUF_FIELD_OFFSET(ConnectionResponseFrame, os_info_)>( + reinterpret_cast(&os_info_), + reinterpret_cast(&other->os_info_)); } std::string ConnectionResponseFrame::GetTypeName() const { @@ -9814,6 +9952,199 @@ std::string LocationStandard::GetTypeName() const { } +// =================================================================== + +class OsInfo::_Internal { + public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_type(HasBits* has_bits) { + (*has_bits)[0] |= 1u; + } +}; + +OsInfo::OsInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:location.nearby.connections.OsInfo) +} +OsInfo::OsInfo(const OsInfo& from) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:location.nearby.connections.OsInfo) +} + +inline void OsInfo::SharedCtor() { +type_ = 0; +} + +OsInfo::~OsInfo() { + // @@protoc_insertion_point(destructor:location.nearby.connections.OsInfo) + if (GetArenaForAllocation() != nullptr) return; + SharedDtor(); + _internal_metadata_.Delete(); +} + +inline void OsInfo::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void OsInfo::ArenaDtor(void* object) { + OsInfo* _this = reinterpret_cast< OsInfo* >(object); + (void)_this; +} +void OsInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void OsInfo::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void OsInfo::Clear() { +// @@protoc_insertion_point(message_clear_start:location.nearby.connections.OsInfo) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char* OsInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .location.nearby.connections.OsInfo.OsType type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(::location::nearby::connections::OsInfo_OsType_IsValid(val))) { + _internal_set_type(static_cast<::location::nearby::connections::OsInfo_OsType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* OsInfo::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:location.nearby.connections.OsInfo) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .location.nearby.connections.OsInfo.OsType type = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast(_internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:location.nearby.connections.OsInfo) + return target; +} + +size_t OsInfo::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:location.nearby.connections.OsInfo) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // optional .location.nearby.connections.OsInfo.OsType type = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void OsInfo::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast( + &from)); +} + +void OsInfo::MergeFrom(const OsInfo& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.connections.OsInfo) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_type()) { + _internal_set_type(from._internal_type()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void OsInfo::CopyFrom(const OsInfo& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.connections.OsInfo) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool OsInfo::IsInitialized() const { + return true; +} + +void OsInfo::InternalSwap(OsInfo* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(type_, other->type_); +} + +std::string OsInfo::GetTypeName() const { + return "location.nearby.connections.OsInfo"; +} + + // @@protoc_insertion_point(namespace_scope) } // namespace connections } // namespace nearby @@ -9906,6 +10237,9 @@ template<> PROTOBUF_NOINLINE ::location::nearby::connections::LocationHint* Aren template<> PROTOBUF_NOINLINE ::location::nearby::connections::LocationStandard* Arena::CreateMaybeMessage< ::location::nearby::connections::LocationStandard >(Arena* arena) { return Arena::CreateMessageInternal< ::location::nearby::connections::LocationStandard >(arena); } +template<> PROTOBUF_NOINLINE ::location::nearby::connections::OsInfo* Arena::CreateMaybeMessage< ::location::nearby::connections::OsInfo >(Arena* arena) { + return Arena::CreateMessageInternal< ::location::nearby::connections::OsInfo >(arena); +} PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) diff --git a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h index d9de2a8d..6c8a4783 100644 --- a/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h +++ b/compiled_proto/connections/implementation/proto/offline_wire_formats.pb.h @@ -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[29] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[30] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -111,6 +111,9 @@ extern MediumMetadataDefaultTypeInternal _MediumMetadata_default_instance_; class OfflineFrame; struct OfflineFrameDefaultTypeInternal; extern OfflineFrameDefaultTypeInternal _OfflineFrame_default_instance_; +class OsInfo; +struct OsInfoDefaultTypeInternal; +extern OsInfoDefaultTypeInternal _OsInfo_default_instance_; class PairedKeyEncryptionFrame; struct PairedKeyEncryptionFrameDefaultTypeInternal; extern PairedKeyEncryptionFrameDefaultTypeInternal _PairedKeyEncryptionFrame_default_instance_; @@ -164,6 +167,7 @@ template<> ::location::nearby::connections::LocationHint* Arena::CreateMaybeMess template<> ::location::nearby::connections::LocationStandard* Arena::CreateMaybeMessage<::location::nearby::connections::LocationStandard>(Arena*); template<> ::location::nearby::connections::MediumMetadata* Arena::CreateMaybeMessage<::location::nearby::connections::MediumMetadata>(Arena*); template<> ::location::nearby::connections::OfflineFrame* Arena::CreateMaybeMessage<::location::nearby::connections::OfflineFrame>(Arena*); +template<> ::location::nearby::connections::OsInfo* Arena::CreateMaybeMessage<::location::nearby::connections::OsInfo>(Arena*); template<> ::location::nearby::connections::PairedKeyEncryptionFrame* Arena::CreateMaybeMessage<::location::nearby::connections::PairedKeyEncryptionFrame>(Arena*); template<> ::location::nearby::connections::PayloadTransferFrame* Arena::CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame>(Arena*); template<> ::location::nearby::connections::PayloadTransferFrame_ControlMessage* Arena::CreateMaybeMessage<::location::nearby::connections::PayloadTransferFrame_ControlMessage>(Arena*); @@ -423,6 +427,29 @@ inline const std::string& LocationStandard_Format_Name(T enum_t_value) { } bool LocationStandard_Format_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LocationStandard_Format* value); +enum OsInfo_OsType : int { + OsInfo_OsType_UNKNOWN_OS_TYPE = 0, + OsInfo_OsType_ANDROID = 1, + OsInfo_OsType_CHROME_OS = 2, + OsInfo_OsType_WINDOWS = 3, + OsInfo_OsType_APPLE = 4, + OsInfo_OsType_LINUX = 100 +}; +bool OsInfo_OsType_IsValid(int value); +constexpr OsInfo_OsType OsInfo_OsType_OsType_MIN = OsInfo_OsType_UNKNOWN_OS_TYPE; +constexpr OsInfo_OsType OsInfo_OsType_OsType_MAX = OsInfo_OsType_LINUX; +constexpr int OsInfo_OsType_OsType_ARRAYSIZE = OsInfo_OsType_OsType_MAX + 1; + +const std::string& OsInfo_OsType_Name(OsInfo_OsType value); +template +inline const std::string& OsInfo_OsType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OsInfo_OsType_Name."); + return OsInfo_OsType_Name(static_cast(enum_t_value)); +} +bool OsInfo_OsType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OsInfo_OsType* value); // =================================================================== class OfflineFrame final : @@ -1447,6 +1474,7 @@ class ConnectionResponseFrame final : enum : int { kHandshakeDataFieldNumber = 2, + kOsInfoFieldNumber = 4, kStatusFieldNumber = 1, kResponseFieldNumber = 3, }; @@ -1468,6 +1496,24 @@ class ConnectionResponseFrame final : std::string* _internal_mutable_handshake_data(); public: + // optional .location.nearby.connections.OsInfo os_info = 4; + bool has_os_info() const; + private: + bool _internal_has_os_info() const; + public: + void clear_os_info(); + const ::location::nearby::connections::OsInfo& os_info() const; + PROTOBUF_NODISCARD ::location::nearby::connections::OsInfo* release_os_info(); + ::location::nearby::connections::OsInfo* mutable_os_info(); + void set_allocated_os_info(::location::nearby::connections::OsInfo* os_info); + private: + const ::location::nearby::connections::OsInfo& _internal_os_info() const; + ::location::nearby::connections::OsInfo* _internal_mutable_os_info(); + public: + void unsafe_arena_set_allocated_os_info( + ::location::nearby::connections::OsInfo* os_info); + ::location::nearby::connections::OsInfo* unsafe_arena_release_os_info(); + // optional int32 status = 1 [deprecated = true]; PROTOBUF_DEPRECATED bool has_status() const; private: @@ -1504,6 +1550,7 @@ class ConnectionResponseFrame final : ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr handshake_data_; + ::location::nearby::connections::OsInfo* os_info_; int32_t status_; int response_; friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; @@ -6184,6 +6231,182 @@ class LocationStandard final : mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; }; +// ------------------------------------------------------------------- + +class OsInfo final : + public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.connections.OsInfo) */ { + public: + inline OsInfo() : OsInfo(nullptr) {} + ~OsInfo() override; + explicit constexpr OsInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + OsInfo(const OsInfo& from); + OsInfo(OsInfo&& from) noexcept + : OsInfo() { + *this = ::std::move(from); + } + + inline OsInfo& operator=(const OsInfo& from) { + CopyFrom(from); + return *this; + } + inline OsInfo& operator=(OsInfo&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const { + return _internal_metadata_.unknown_fields(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const OsInfo& default_instance() { + return *internal_default_instance(); + } + static inline const OsInfo* internal_default_instance() { + return reinterpret_cast( + &_OsInfo_default_instance_); + } + static constexpr int kIndexInFileMessages = + 29; + + friend void swap(OsInfo& a, OsInfo& b) { + a.Swap(&b); + } + inline void Swap(OsInfo* 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(OsInfo* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + OsInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final; + void CopyFrom(const OsInfo& from); + void MergeFrom(const OsInfo& 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(OsInfo* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "location.nearby.connections.OsInfo"; + } + protected: + explicit OsInfo(::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 OsInfo_OsType OsType; + static constexpr OsType UNKNOWN_OS_TYPE = + OsInfo_OsType_UNKNOWN_OS_TYPE; + static constexpr OsType ANDROID = + OsInfo_OsType_ANDROID; + static constexpr OsType CHROME_OS = + OsInfo_OsType_CHROME_OS; + static constexpr OsType WINDOWS = + OsInfo_OsType_WINDOWS; + static constexpr OsType APPLE = + OsInfo_OsType_APPLE; + static constexpr OsType LINUX = + OsInfo_OsType_LINUX; + static inline bool OsType_IsValid(int value) { + return OsInfo_OsType_IsValid(value); + } + static constexpr OsType OsType_MIN = + OsInfo_OsType_OsType_MIN; + static constexpr OsType OsType_MAX = + OsInfo_OsType_OsType_MAX; + static constexpr int OsType_ARRAYSIZE = + OsInfo_OsType_OsType_ARRAYSIZE; + template + static inline const std::string& OsType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OsType_Name."); + return OsInfo_OsType_Name(enum_t_value); + } + static inline bool OsType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + OsType* value) { + return OsInfo_OsType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kTypeFieldNumber = 1, + }; + // optional .location.nearby.connections.OsInfo.OsType type = 1; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + ::location::nearby::connections::OsInfo_OsType type() const; + void set_type(::location::nearby::connections::OsInfo_OsType value); + private: + ::location::nearby::connections::OsInfo_OsType _internal_type() const; + void _internal_set_type(::location::nearby::connections::OsInfo_OsType value); + public: + + // @@protoc_insertion_point(class_scope:location.nearby.connections.OsInfo) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int type_; + friend struct ::TableStruct_connections_2fimplementation_2fproto_2foffline_5fwire_5fformats_2eproto; +}; // =================================================================== @@ -7579,7 +7802,7 @@ inline void ConnectionRequestFrame::set_allocated_device_info(std::string* devic // optional int32 status = 1 [deprecated = true]; inline bool ConnectionResponseFrame::_internal_has_status() const { - bool value = (_has_bits_[0] & 0x00000002u) != 0; + bool value = (_has_bits_[0] & 0x00000004u) != 0; return value; } inline bool ConnectionResponseFrame::has_status() const { @@ -7587,7 +7810,7 @@ inline bool ConnectionResponseFrame::has_status() const { } inline void ConnectionResponseFrame::clear_status() { status_ = 0; - _has_bits_[0] &= ~0x00000002u; + _has_bits_[0] &= ~0x00000004u; } inline int32_t ConnectionResponseFrame::_internal_status() const { return status_; @@ -7597,7 +7820,7 @@ inline int32_t ConnectionResponseFrame::status() const { return _internal_status(); } inline void ConnectionResponseFrame::_internal_set_status(int32_t value) { - _has_bits_[0] |= 0x00000002u; + _has_bits_[0] |= 0x00000004u; status_ = value; } inline void ConnectionResponseFrame::set_status(int32_t value) { @@ -7676,7 +7899,7 @@ inline void ConnectionResponseFrame::set_allocated_handshake_data(std::string* h // optional .location.nearby.connections.ConnectionResponseFrame.ResponseStatus response = 3; inline bool ConnectionResponseFrame::_internal_has_response() const { - bool value = (_has_bits_[0] & 0x00000004u) != 0; + bool value = (_has_bits_[0] & 0x00000008u) != 0; return value; } inline bool ConnectionResponseFrame::has_response() const { @@ -7684,7 +7907,7 @@ inline bool ConnectionResponseFrame::has_response() const { } inline void ConnectionResponseFrame::clear_response() { response_ = 0; - _has_bits_[0] &= ~0x00000004u; + _has_bits_[0] &= ~0x00000008u; } inline ::location::nearby::connections::ConnectionResponseFrame_ResponseStatus ConnectionResponseFrame::_internal_response() const { return static_cast< ::location::nearby::connections::ConnectionResponseFrame_ResponseStatus >(response_); @@ -7695,7 +7918,7 @@ inline ::location::nearby::connections::ConnectionResponseFrame_ResponseStatus C } inline void ConnectionResponseFrame::_internal_set_response(::location::nearby::connections::ConnectionResponseFrame_ResponseStatus value) { assert(::location::nearby::connections::ConnectionResponseFrame_ResponseStatus_IsValid(value)); - _has_bits_[0] |= 0x00000004u; + _has_bits_[0] |= 0x00000008u; response_ = value; } inline void ConnectionResponseFrame::set_response(::location::nearby::connections::ConnectionResponseFrame_ResponseStatus value) { @@ -7703,6 +7926,96 @@ inline void ConnectionResponseFrame::set_response(::location::nearby::connection // @@protoc_insertion_point(field_set:location.nearby.connections.ConnectionResponseFrame.response) } +// optional .location.nearby.connections.OsInfo os_info = 4; +inline bool ConnectionResponseFrame::_internal_has_os_info() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || os_info_ != nullptr); + return value; +} +inline bool ConnectionResponseFrame::has_os_info() const { + return _internal_has_os_info(); +} +inline void ConnectionResponseFrame::clear_os_info() { + if (os_info_ != nullptr) os_info_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::location::nearby::connections::OsInfo& ConnectionResponseFrame::_internal_os_info() const { + const ::location::nearby::connections::OsInfo* p = os_info_; + return p != nullptr ? *p : reinterpret_cast( + ::location::nearby::connections::_OsInfo_default_instance_); +} +inline const ::location::nearby::connections::OsInfo& ConnectionResponseFrame::os_info() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.ConnectionResponseFrame.os_info) + return _internal_os_info(); +} +inline void ConnectionResponseFrame::unsafe_arena_set_allocated_os_info( + ::location::nearby::connections::OsInfo* os_info) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(os_info_); + } + os_info_ = os_info; + if (os_info) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.connections.ConnectionResponseFrame.os_info) +} +inline ::location::nearby::connections::OsInfo* ConnectionResponseFrame::release_os_info() { + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::OsInfo* temp = os_info_; + os_info_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::location::nearby::connections::OsInfo* ConnectionResponseFrame::unsafe_arena_release_os_info() { + // @@protoc_insertion_point(field_release:location.nearby.connections.ConnectionResponseFrame.os_info) + _has_bits_[0] &= ~0x00000002u; + ::location::nearby::connections::OsInfo* temp = os_info_; + os_info_ = nullptr; + return temp; +} +inline ::location::nearby::connections::OsInfo* ConnectionResponseFrame::_internal_mutable_os_info() { + _has_bits_[0] |= 0x00000002u; + if (os_info_ == nullptr) { + auto* p = CreateMaybeMessage<::location::nearby::connections::OsInfo>(GetArenaForAllocation()); + os_info_ = p; + } + return os_info_; +} +inline ::location::nearby::connections::OsInfo* ConnectionResponseFrame::mutable_os_info() { + ::location::nearby::connections::OsInfo* _msg = _internal_mutable_os_info(); + // @@protoc_insertion_point(field_mutable:location.nearby.connections.ConnectionResponseFrame.os_info) + return _msg; +} +inline void ConnectionResponseFrame::set_allocated_os_info(::location::nearby::connections::OsInfo* os_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete os_info_; + } + if (os_info) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::connections::OsInfo>::GetOwningArena(os_info); + if (message_arena != submessage_arena) { + os_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, os_info, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + os_info_ = os_info; + // @@protoc_insertion_point(field_set_allocated:location.nearby.connections.ConnectionResponseFrame.os_info) +} + // ------------------------------------------------------------------- // PayloadTransferFrame_PayloadHeader @@ -11795,6 +12108,39 @@ inline void LocationHint::set_format(::location::nearby::connections::LocationSt // LocationStandard +// ------------------------------------------------------------------- + +// OsInfo + +// optional .location.nearby.connections.OsInfo.OsType type = 1; +inline bool OsInfo::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool OsInfo::has_type() const { + return _internal_has_type(); +} +inline void OsInfo::clear_type() { + type_ = 0; + _has_bits_[0] &= ~0x00000001u; +} +inline ::location::nearby::connections::OsInfo_OsType OsInfo::_internal_type() const { + return static_cast< ::location::nearby::connections::OsInfo_OsType >(type_); +} +inline ::location::nearby::connections::OsInfo_OsType OsInfo::type() const { + // @@protoc_insertion_point(field_get:location.nearby.connections.OsInfo.type) + return _internal_type(); +} +inline void OsInfo::_internal_set_type(::location::nearby::connections::OsInfo_OsType value) { + assert(::location::nearby::connections::OsInfo_OsType_IsValid(value)); + _has_bits_[0] |= 0x00000001u; + type_ = value; +} +inline void OsInfo::set_type(::location::nearby::connections::OsInfo_OsType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:location.nearby.connections.OsInfo.type) +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -11854,6 +12200,8 @@ inline void LocationHint::set_format(::location::nearby::connections::LocationSt // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) @@ -11874,6 +12222,7 @@ template <> struct is_proto_enum< ::location::nearby::connections::PayloadTransf template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_UpgradePathInfo_Medium> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::BandwidthUpgradeNegotiationFrame_EventType> : ::std::true_type {}; template <> struct is_proto_enum< ::location::nearby::connections::LocationStandard_Format> : ::std::true_type {}; +template <> struct is_proto_enum< ::location::nearby::connections::OsInfo_OsType> : ::std::true_type {}; PROTOBUF_NAMESPACE_CLOSE