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

Merge pull request #554 from deling-google/symlink

Browse Source 
Restructure third_party folder to enable building for iOS
This commit is contained in:
suetfei
2022-03-31 16:22:09 -07:00
committed by GitHub
parent 42fa8561fc 58352df21c
commit 3fa664c37b
44 changed files with 83467 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+1
View File
@@ -1 +1,2 @@
build/**
.build
.gitmodules
+17 -9
View File
@@ -1,11 +1,7 @@
[submodule "third_party/ukey2"]
path = third_party/ukey2
url = https://github.com/google/ukey2
branch = master
[submodule "third_party/protobuf"]
path = third_party/protobuf
url = https://github.com/protocolbuffers/protobuf
branch = master
branch = 3.19.x
[submodule "third_party/gtest"]
path = third_party/gtest
url = https://github.com/google/googletest
@@ -14,11 +10,23 @@
path = third_party/absl
url = https://github.com/abseil/abseil-cpp
branch = master
[submodule "third_party/smhasher"]
path = third_party/smhasher
url = https://github.com/aappleby/smhasher
branch = master
[submodule "third_party/depot_tools"]
path = third_party/depot_tools
url = https://chromium.googlesource.com/chromium/tools/depot_tools.git
branch = main
[submodule "third_party/ukey2/ukey2"]
path = third_party/ukey2/ukey2
url = https://github.com/google/ukey2
branch = master
[submodule "third_party/smhasher/smhasher"]
path = third_party/smhasher/smhasher
url = https://github.com/aappleby/smhasher
branch = master
[submodule "third_party/securemessage/securemessage"]
path = third_party/securemessage/securemessage
url = https://github.com/google/securemessage.git
branch = master
[submodule "third_party/google-toolbox-for-mac/google-toolbox-for-mac"]
path = third_party/google-toolbox-for-mac/google-toolbox-for-mac
url = https://github.com/google/google-toolbox-for-mac.git
branch = main
Package.resolved
+25
View File
@@ -0,0 +1,25 @@
{
"object": {
"pins": [
{
"package": "abseil",
"repositoryURL": "https://github.com/firebase/abseil-cpp-SwiftPM.git",
"state": {
"branch": "main",
"revision": "d302de612e3d57c6f4afaf087da18fba8eac72a7",
"version": null
}
},
{
"package": "BoringSSL-GRPC",
"repositoryURL": "https://github.com/firebase/boringssl-SwiftPM.git",
"state": {
"branch": null,
"revision": "734a8247442fde37df4364c21f6a0085b6a36728",
"version": "0.7.2"
}
}
]
},
"version": 1
}
Package.swift
+82 -82
View File
@@ -28,93 +28,93 @@ let package = Package(
// Targets are the basic building blocks of a package. A target can define a module or a test suite.
// Targets can depend on other targets in this package, and on products in packages this package depends on.
.target(
name: "google_toolbox_for_mac",
path: "third_party/google_toolbox_for_mac",
name: "google-toolbox-for-mac",
path: "third_party/google-toolbox-for-mac",
exclude: [
"google_toolbox_for_mac/Foundation/GTMNSString+HTMLTest.m",
"google_toolbox_for_mac/Foundation/GTMSystemVersionTest.m",
"google_toolbox_for_mac/Foundation/GTMNSFileHandle+UniqueName.m",
"google_toolbox_for_mac/Foundation/GTMLoggerRingBufferWriterTest.m",
"google_toolbox_for_mac/Foundation/GTMNSData+zlib.m",
"google_toolbox_for_mac/Foundation/GTMNSNumber+64BitTest.m",
"google_toolbox_for_mac/Foundation/GTMScriptRunnerTest.m",
"google_toolbox_for_mac/Foundation/GTMSystemVersion.m",
"google_toolbox_for_mac/Foundation/GTMFileSystemKQueueTest.m",
"google_toolbox_for_mac/Foundation/GTMFileSystemKQueue.m",
"google_toolbox_for_mac/Foundation/GTMGeometryUtilsTest.m",
"google_toolbox_for_mac/Foundation/GTMLocalizedStringTest.m",
"google_toolbox_for_mac/Foundation/BUILD",
"google_toolbox_for_mac/Foundation/GTMSQLite.m",
"google_toolbox_for_mac/Foundation/GTMLoggerRingBufferWriter.m",
"google_toolbox_for_mac/Foundation/GTMStringEncoding.m",
"google_toolbox_for_mac/Foundation/GTMNSFileHandle+UniqueNameTest.m",
"google_toolbox_for_mac/Foundation/GTMLogger+ASLTest.m",
"google_toolbox_for_mac/Foundation/GTMNSObject+KeyValueObservingTest.m",
"google_toolbox_for_mac/Foundation/GTMNSString+XMLTest.m",
"google_toolbox_for_mac/Foundation/GTMNSThread+BlocksTest.m",
"google_toolbox_for_mac/Foundation/GTMNSString+HTML.m",
"google_toolbox_for_mac/Foundation/GTMSignalHandlerTest.m",
"google_toolbox_for_mac/Foundation/GTMURLBuilderTest.m",
"google_toolbox_for_mac/Foundation/GTMLoggerTest.m",
"google_toolbox_for_mac/Foundation/GTMServiceManagementTestingHarness.c",
"google_toolbox_for_mac/Foundation/GTMSQLiteTest.m",
"google_toolbox_for_mac/Foundation/GTMTimeUtilsTest.m",
"google_toolbox_for_mac/Foundation/GTMNSFileManager+PathTest.m",
"google_toolbox_for_mac/Foundation/GTMServiceManagement.c",
"google_toolbox_for_mac/Foundation/GTMNSString+URLArgumentsTest.m",
"google_toolbox_for_mac/Foundation/GTMRegexTest.m",
"google_toolbox_for_mac/Foundation/GTMNSThread+Blocks.m",
"google_toolbox_for_mac/Foundation/GTMNSScanner+JSONTest.m",
"google_toolbox_for_mac/Foundation/GTMNSData+zlibTest.m",
"google_toolbox_for_mac/Foundation/GTMNSDictionary+URLArgumentsTest.m",
"google_toolbox_for_mac/Foundation/GTMLogger+ASL.m",
"google_toolbox_for_mac/Foundation/GTMServiceManagementTest.m",
"google_toolbox_for_mac/Foundation/GTMNSString+URLArguments.m",
"google_toolbox_for_mac/Foundation/GTMNSNumber+64Bit.m",
"google_toolbox_for_mac/Foundation/GTMNSScanner+JSON.m",
"google_toolbox_for_mac/Foundation/GTMGeometryUtils.m",
"google_toolbox_for_mac/Foundation/GTMRegex.m",
"google_toolbox_for_mac/Foundation/GTMScriptRunner.m",
"google_toolbox_for_mac/Foundation/GTMStackTrace.m",
"google_toolbox_for_mac/Foundation/GTMURLBuilder.m",
"google_toolbox_for_mac/Foundation/GTMNSString+FindFolderTest.m",
"google_toolbox_for_mac/Foundation/GTMObjC2Runtime.m",
"google_toolbox_for_mac/Foundation/GTMNSString+FindFolder.m",
"google_toolbox_for_mac/Foundation/GTMNSDictionary+URLArguments.m",
"google_toolbox_for_mac/Foundation/GTMStackTraceTest.m",
"google_toolbox_for_mac/Foundation/GTMLightweightProxyTest.m",
"google_toolbox_for_mac/Foundation/GTMNSFileManager+Path.m",
"google_toolbox_for_mac/Foundation/GTMStringEncodingTest.m",
"google_toolbox_for_mac/Foundation/GTMNSObject+KeyValueObserving.m",
"google_toolbox_for_mac/Foundation/GTMTimeUtils.m",
"google_toolbox_for_mac/Foundation/GTMSignalHandler.m",
"google_toolbox_for_mac/Foundation/GTMNSString+XML.m",
"google_toolbox_for_mac/Foundation/GTMLightweightProxy.m",
"google_toolbox_for_mac/AppKit",
"google_toolbox_for_mac/DebugUtils",
"google_toolbox_for_mac/LICENSE",
"google_toolbox_for_mac/WORKSPACE",
"google_toolbox_for_mac/BUILD",
"google_toolbox_for_mac/GTMiPhone-Info.plist",
"google_toolbox_for_mac/README.md",
"google_toolbox_for_mac/XcodeConfig",
"google_toolbox_for_mac/BuildingAndUsing.txt",
"google_toolbox_for_mac/GTM-Info.plist",
"google_toolbox_for_mac/GTMiPhone.xcodeproj",
"google_toolbox_for_mac/UnitTest-Info.plist",
"google_toolbox_for_mac/bazel_support",
"google_toolbox_for_mac/CONTRIBUTING.md",
"google_toolbox_for_mac/GTM.xcodeproj",
"google_toolbox_for_mac/GoogleToolboxForMac.podspec",
"google_toolbox_for_mac/UnitTesting",
"google_toolbox_for_mac/iPhone",
"google-toolbox-for-mac/Foundation/GTMNSString+HTMLTest.m",
"google-toolbox-for-mac/Foundation/GTMSystemVersionTest.m",
"google-toolbox-for-mac/Foundation/GTMNSFileHandle+UniqueName.m",
"google-toolbox-for-mac/Foundation/GTMLoggerRingBufferWriterTest.m",
"google-toolbox-for-mac/Foundation/GTMNSData+zlib.m",
"google-toolbox-for-mac/Foundation/GTMNSNumber+64BitTest.m",
"google-toolbox-for-mac/Foundation/GTMScriptRunnerTest.m",
"google-toolbox-for-mac/Foundation/GTMSystemVersion.m",
"google-toolbox-for-mac/Foundation/GTMFileSystemKQueueTest.m",
"google-toolbox-for-mac/Foundation/GTMFileSystemKQueue.m",
"google-toolbox-for-mac/Foundation/GTMGeometryUtilsTest.m",
"google-toolbox-for-mac/Foundation/GTMLocalizedStringTest.m",
"google-toolbox-for-mac/Foundation/BUILD",
"google-toolbox-for-mac/Foundation/GTMSQLite.m",
"google-toolbox-for-mac/Foundation/GTMLoggerRingBufferWriter.m",
"google-toolbox-for-mac/Foundation/GTMStringEncoding.m",
"google-toolbox-for-mac/Foundation/GTMNSFileHandle+UniqueNameTest.m",
"google-toolbox-for-mac/Foundation/GTMLogger+ASLTest.m",
"google-toolbox-for-mac/Foundation/GTMNSObject+KeyValueObservingTest.m",
"google-toolbox-for-mac/Foundation/GTMNSString+XMLTest.m",
"google-toolbox-for-mac/Foundation/GTMNSThread+BlocksTest.m",
"google-toolbox-for-mac/Foundation/GTMNSString+HTML.m",
"google-toolbox-for-mac/Foundation/GTMSignalHandlerTest.m",
"google-toolbox-for-mac/Foundation/GTMURLBuilderTest.m",
"google-toolbox-for-mac/Foundation/GTMLoggerTest.m",
"google-toolbox-for-mac/Foundation/GTMServiceManagementTestingHarness.c",
"google-toolbox-for-mac/Foundation/GTMSQLiteTest.m",
"google-toolbox-for-mac/Foundation/GTMTimeUtilsTest.m",
"google-toolbox-for-mac/Foundation/GTMNSFileManager+PathTest.m",
"google-toolbox-for-mac/Foundation/GTMServiceManagement.c",
"google-toolbox-for-mac/Foundation/GTMNSString+URLArgumentsTest.m",
"google-toolbox-for-mac/Foundation/GTMRegexTest.m",
"google-toolbox-for-mac/Foundation/GTMNSThread+Blocks.m",
"google-toolbox-for-mac/Foundation/GTMNSScanner+JSONTest.m",
"google-toolbox-for-mac/Foundation/GTMNSData+zlibTest.m",
"google-toolbox-for-mac/Foundation/GTMNSDictionary+URLArgumentsTest.m",
"google-toolbox-for-mac/Foundation/GTMLogger+ASL.m",
"google-toolbox-for-mac/Foundation/GTMServiceManagementTest.m",
"google-toolbox-for-mac/Foundation/GTMNSString+URLArguments.m",
"google-toolbox-for-mac/Foundation/GTMNSNumber+64Bit.m",
"google-toolbox-for-mac/Foundation/GTMNSScanner+JSON.m",
"google-toolbox-for-mac/Foundation/GTMGeometryUtils.m",
"google-toolbox-for-mac/Foundation/GTMRegex.m",
"google-toolbox-for-mac/Foundation/GTMScriptRunner.m",
"google-toolbox-for-mac/Foundation/GTMStackTrace.m",
"google-toolbox-for-mac/Foundation/GTMURLBuilder.m",
"google-toolbox-for-mac/Foundation/GTMNSString+FindFolderTest.m",
"google-toolbox-for-mac/Foundation/GTMObjC2Runtime.m",
"google-toolbox-for-mac/Foundation/GTMNSString+FindFolder.m",
"google-toolbox-for-mac/Foundation/GTMNSDictionary+URLArguments.m",
"google-toolbox-for-mac/Foundation/GTMStackTraceTest.m",
"google-toolbox-for-mac/Foundation/GTMLightweightProxyTest.m",
"google-toolbox-for-mac/Foundation/GTMNSFileManager+Path.m",
"google-toolbox-for-mac/Foundation/GTMStringEncodingTest.m",
"google-toolbox-for-mac/Foundation/GTMNSObject+KeyValueObserving.m",
"google-toolbox-for-mac/Foundation/GTMTimeUtils.m",
"google-toolbox-for-mac/Foundation/GTMSignalHandler.m",
"google-toolbox-for-mac/Foundation/GTMNSString+XML.m",
"google-toolbox-for-mac/Foundation/GTMLightweightProxy.m",
"google-toolbox-for-mac/AppKit",
"google-toolbox-for-mac/DebugUtils",
"google-toolbox-for-mac/LICENSE",
"google-toolbox-for-mac/WORKSPACE",
"google-toolbox-for-mac/BUILD",
"google-toolbox-for-mac/GTMiPhone-Info.plist",
"google-toolbox-for-mac/README.md",
"google-toolbox-for-mac/XcodeConfig",
"google-toolbox-for-mac/BuildingAndUsing.txt",
"google-toolbox-for-mac/GTM-Info.plist",
"google-toolbox-for-mac/GTMiPhone.xcodeproj",
"google-toolbox-for-mac/UnitTest-Info.plist",
"google-toolbox-for-mac/bazel_support",
"google-toolbox-for-mac/CONTRIBUTING.md",
"google-toolbox-for-mac/GTM.xcodeproj",
"google-toolbox-for-mac/GoogleToolboxForMac.podspec",
"google-toolbox-for-mac/UnitTesting",
"google-toolbox-for-mac/iPhone",
],
sources: [
"google_toolbox_for_mac/Foundation/GTMLogger.m"
"google-toolbox-for-mac/Foundation/GTMLogger.m"
],
publicHeadersPath: "include",
cSettings: [
.headerSearchPath("google_toolbox_for_mac/"),
.headerSearchPath("google-toolbox-for-mac/"),
.unsafeFlags(["-fno-objc-arc"]),
]
),
@@ -361,7 +361,7 @@ let package = Package(
.target(
name: "NearbyConnections",
dependencies: [
"google_toolbox_for_mac",
"google-toolbox-for-mac",
"smhasher",
"ukey2",
"protobuf",
connections/implementation/proto/offline_wire_formats.pb.cc
+9857
View File
File diff suppressed because it is too large Load Diff
connections/implementation/proto/offline_wire_formats.pb.h
+11796
View File
File diff suppressed because it is too large Load Diff
internal/proto/analytics/connections_log.pb.cc
+7261
View File
File diff suppressed because it is too large Load Diff
internal/proto/analytics/connections_log.pb.h
+8625
View File
File diff suppressed because it is too large Load Diff
proto/connections_enums.pb.cc
+1348
View File
File diff suppressed because it is too large Load Diff
proto/connections_enums.pb.h
+542
View File
@@ -0,0 +1,542 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: proto/connections_enums.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fconnections_5fenums_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fconnections_5fenums_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_proto_2fconnections_5fenums_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2fconnections_5fenums_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
PROTOBUF_NAMESPACE_OPEN
PROTOBUF_NAMESPACE_CLOSE
namespace location {
namespace nearby {
namespace proto {
namespace connections {
enum EventType : int {
UNKNOWN_EVENT_TYPE = 0,
CLIENT_SESSION = 1,
START_CLIENT_SESSION = 2,
STOP_CLIENT_SESSION = 3,
START_STRATEGY_SESSION = 4,
STOP_STRATEGY_SESSION = 5,
ERROR_CODE = 6
};
bool EventType_IsValid(int value);
constexpr EventType EventType_MIN = UNKNOWN_EVENT_TYPE;
constexpr EventType EventType_MAX = ERROR_CODE;
constexpr int EventType_ARRAYSIZE = EventType_MAX + 1;
const std::string& EventType_Name(EventType value);
template<typename T>
inline const std::string& EventType_Name(T enum_t_value) {
static_assert(::std::is_same<T, EventType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function EventType_Name.");
return EventType_Name(static_cast<EventType>(enum_t_value));
}
bool EventType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventType* value);
enum ConnectionsStrategy : int {
UNKNOWN_STRATEGY = 0,
MDNS_LOCAL_WIFI PROTOBUF_DEPRECATED_ENUM = 1,
RADIO_P2P PROTOBUF_DEPRECATED_ENUM = 2,
P2P_CLUSTER = 3,
P2P_STAR = 4,
P2P_POINT_TO_POINT = 5
};
bool ConnectionsStrategy_IsValid(int value);
constexpr ConnectionsStrategy ConnectionsStrategy_MIN = UNKNOWN_STRATEGY;
constexpr ConnectionsStrategy ConnectionsStrategy_MAX = P2P_POINT_TO_POINT;
constexpr int ConnectionsStrategy_ARRAYSIZE = ConnectionsStrategy_MAX + 1;
const std::string& ConnectionsStrategy_Name(ConnectionsStrategy value);
template<typename T>
inline const std::string& ConnectionsStrategy_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConnectionsStrategy>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConnectionsStrategy_Name.");
return ConnectionsStrategy_Name(static_cast<ConnectionsStrategy>(enum_t_value));
}
bool ConnectionsStrategy_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionsStrategy* value);
enum SessionRole : int {
UNKNOWN_SESSION_ROLE = 0,
ADVERTISER = 1,
DISCOVERER = 2
};
bool SessionRole_IsValid(int value);
constexpr SessionRole SessionRole_MIN = UNKNOWN_SESSION_ROLE;
constexpr SessionRole SessionRole_MAX = DISCOVERER;
constexpr int SessionRole_ARRAYSIZE = SessionRole_MAX + 1;
const std::string& SessionRole_Name(SessionRole value);
template<typename T>
inline const std::string& SessionRole_Name(T enum_t_value) {
static_assert(::std::is_same<T, SessionRole>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SessionRole_Name.");
return SessionRole_Name(static_cast<SessionRole>(enum_t_value));
}
bool SessionRole_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SessionRole* value);
enum Medium : int {
UNKNOWN_MEDIUM = 0,
MDNS PROTOBUF_DEPRECATED_ENUM = 1,
BLUETOOTH = 2,
WIFI_HOTSPOT = 3,
BLE = 4,
WIFI_LAN = 5,
WIFI_AWARE = 6,
NFC = 7,
WIFI_DIRECT = 8,
WEB_RTC = 9,
BLE_L2CAP = 10
};
bool Medium_IsValid(int value);
constexpr Medium Medium_MIN = UNKNOWN_MEDIUM;
constexpr Medium Medium_MAX = BLE_L2CAP;
constexpr int Medium_ARRAYSIZE = Medium_MAX + 1;
const std::string& Medium_Name(Medium value);
template<typename T>
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 Medium_Name(static_cast<Medium>(enum_t_value));
}
bool Medium_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Medium* value);
enum ConnectionTechnology : int {
CONNECTION_TECHNOLOGY_UNKNOWN_TECHNOLOGY = 0,
CONNECTION_TECHNOLOGY_BLE_GATT = 1,
CONNECTION_TECHNOLOGY_BLE_L2CAP = 2,
CONNECTION_TECHNOLOGY_HOTSPOT_DIRECT = 3,
CONNECTION_TECHNOLOGY_HOTSPOT_LOCALONLY = 4,
CONNECTION_TECHNOLOGY_HOTSPOT_SOFTAP = 5,
CONNECTION_TECHNOLOGY_WEBRTC_WIFI = 6,
CONNECTION_TECHNOLOGY_WEBRTC_MOBILE = 7,
CONNECTION_TECHNOLOGY_WEBRTC_ETHERNET = 8,
CONNECTION_TECHNOLOGY_WEBRTC_VPN = 9,
CONNECTION_TECHNOLOGY_WEBRTC_LOOPBACK = 10,
CONNECTION_TECHNOLOGY_WEBRTC_ADAPTER_TYPE_ANY = 11
};
bool ConnectionTechnology_IsValid(int value);
constexpr ConnectionTechnology ConnectionTechnology_MIN = CONNECTION_TECHNOLOGY_UNKNOWN_TECHNOLOGY;
constexpr ConnectionTechnology ConnectionTechnology_MAX = CONNECTION_TECHNOLOGY_WEBRTC_ADAPTER_TYPE_ANY;
constexpr int ConnectionTechnology_ARRAYSIZE = ConnectionTechnology_MAX + 1;
const std::string& ConnectionTechnology_Name(ConnectionTechnology value);
template<typename T>
inline const std::string& ConnectionTechnology_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConnectionTechnology>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConnectionTechnology_Name.");
return ConnectionTechnology_Name(static_cast<ConnectionTechnology>(enum_t_value));
}
bool ConnectionTechnology_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionTechnology* value);
enum ConnectionBand : int {
CONNECTION_BAND_UNKNOWN_BAND = 0,
CONNECTION_BAND_WIFI_BAND_2GHZ = 1,
CONNECTION_BAND_WIFI_BAND_5GHZ = 2,
CONNECTION_BAND_WIFI_BAND_6GHZ = 3,
CONNECTION_BAND_CELLULAR_BAND_2G = 4,
CONNECTION_BAND_CELLULAR_BAND_3G = 5,
CONNECTION_BAND_CELLULAR_BAND_4G = 6,
CONNECTION_BAND_CELLULAR_BAND_5G = 7
};
bool ConnectionBand_IsValid(int value);
constexpr ConnectionBand ConnectionBand_MIN = CONNECTION_BAND_UNKNOWN_BAND;
constexpr ConnectionBand ConnectionBand_MAX = CONNECTION_BAND_CELLULAR_BAND_5G;
constexpr int ConnectionBand_ARRAYSIZE = ConnectionBand_MAX + 1;
const std::string& ConnectionBand_Name(ConnectionBand value);
template<typename T>
inline const std::string& ConnectionBand_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConnectionBand>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConnectionBand_Name.");
return ConnectionBand_Name(static_cast<ConnectionBand>(enum_t_value));
}
bool ConnectionBand_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionBand* value);
enum ConnectionRequestResponse : int {
UNKNOWN_CONNECTION_REQUEST_RESPONSE = 0,
ACCEPTED = 1,
REJECTED = 2,
IGNORED = 3,
NOT_SENT = 4
};
bool ConnectionRequestResponse_IsValid(int value);
constexpr ConnectionRequestResponse ConnectionRequestResponse_MIN = UNKNOWN_CONNECTION_REQUEST_RESPONSE;
constexpr ConnectionRequestResponse ConnectionRequestResponse_MAX = NOT_SENT;
constexpr int ConnectionRequestResponse_ARRAYSIZE = ConnectionRequestResponse_MAX + 1;
const std::string& ConnectionRequestResponse_Name(ConnectionRequestResponse value);
template<typename T>
inline const std::string& ConnectionRequestResponse_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConnectionRequestResponse>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConnectionRequestResponse_Name.");
return ConnectionRequestResponse_Name(static_cast<ConnectionRequestResponse>(enum_t_value));
}
bool ConnectionRequestResponse_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionRequestResponse* value);
enum ConnectionAttemptResult : int {
UNKNOWN_CONNECTION_ATTEMPT_RESULT = 0,
RESULT_SUCCESS = 1,
RESULT_ERROR = 2,
RESULT_CANCELLED = 3
};
bool ConnectionAttemptResult_IsValid(int value);
constexpr ConnectionAttemptResult ConnectionAttemptResult_MIN = UNKNOWN_CONNECTION_ATTEMPT_RESULT;
constexpr ConnectionAttemptResult ConnectionAttemptResult_MAX = RESULT_CANCELLED;
constexpr int ConnectionAttemptResult_ARRAYSIZE = ConnectionAttemptResult_MAX + 1;
const std::string& ConnectionAttemptResult_Name(ConnectionAttemptResult value);
template<typename T>
inline const std::string& ConnectionAttemptResult_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConnectionAttemptResult>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConnectionAttemptResult_Name.");
return ConnectionAttemptResult_Name(static_cast<ConnectionAttemptResult>(enum_t_value));
}
bool ConnectionAttemptResult_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionAttemptResult* value);
enum ConnectionAttemptDirection : int {
UNKNOWN_CONNECTION_ATTEMPT_DIRECTION = 0,
INCOMING = 1,
OUTGOING = 2
};
bool ConnectionAttemptDirection_IsValid(int value);
constexpr ConnectionAttemptDirection ConnectionAttemptDirection_MIN = UNKNOWN_CONNECTION_ATTEMPT_DIRECTION;
constexpr ConnectionAttemptDirection ConnectionAttemptDirection_MAX = OUTGOING;
constexpr int ConnectionAttemptDirection_ARRAYSIZE = ConnectionAttemptDirection_MAX + 1;
const std::string& ConnectionAttemptDirection_Name(ConnectionAttemptDirection value);
template<typename T>
inline const std::string& ConnectionAttemptDirection_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConnectionAttemptDirection>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConnectionAttemptDirection_Name.");
return ConnectionAttemptDirection_Name(static_cast<ConnectionAttemptDirection>(enum_t_value));
}
bool ConnectionAttemptDirection_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionAttemptDirection* value);
enum ConnectionAttemptType : int {
UNKNOWN_CONNECTION_ATTEMPT_TYPE = 0,
INITIAL = 1,
UPGRADE = 2
};
bool ConnectionAttemptType_IsValid(int value);
constexpr ConnectionAttemptType ConnectionAttemptType_MIN = UNKNOWN_CONNECTION_ATTEMPT_TYPE;
constexpr ConnectionAttemptType ConnectionAttemptType_MAX = UPGRADE;
constexpr int ConnectionAttemptType_ARRAYSIZE = ConnectionAttemptType_MAX + 1;
const std::string& ConnectionAttemptType_Name(ConnectionAttemptType value);
template<typename T>
inline const std::string& ConnectionAttemptType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConnectionAttemptType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConnectionAttemptType_Name.");
return ConnectionAttemptType_Name(static_cast<ConnectionAttemptType>(enum_t_value));
}
bool ConnectionAttemptType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionAttemptType* value);
enum DisconnectionReason : int {
UNKNOWN_DISCONNECTION_REASON = 0,
LOCAL_DISCONNECTION = 1,
REMOTE_DISCONNECTION = 2,
IO_ERROR = 3,
UPGRADED = 4,
SHUTDOWN = 5,
UNFINISHED = 6
};
bool DisconnectionReason_IsValid(int value);
constexpr DisconnectionReason DisconnectionReason_MIN = UNKNOWN_DISCONNECTION_REASON;
constexpr DisconnectionReason DisconnectionReason_MAX = UNFINISHED;
constexpr int DisconnectionReason_ARRAYSIZE = DisconnectionReason_MAX + 1;
const std::string& DisconnectionReason_Name(DisconnectionReason value);
template<typename T>
inline const std::string& DisconnectionReason_Name(T enum_t_value) {
static_assert(::std::is_same<T, DisconnectionReason>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DisconnectionReason_Name.");
return DisconnectionReason_Name(static_cast<DisconnectionReason>(enum_t_value));
}
bool DisconnectionReason_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisconnectionReason* value);
enum PayloadType : int {
UNKNOWN_PAYLOAD_TYPE = 0,
BYTES = 1,
FILE = 2,
STREAM = 3
};
bool PayloadType_IsValid(int value);
constexpr PayloadType PayloadType_MIN = UNKNOWN_PAYLOAD_TYPE;
constexpr PayloadType PayloadType_MAX = STREAM;
constexpr int PayloadType_ARRAYSIZE = PayloadType_MAX + 1;
const std::string& PayloadType_Name(PayloadType value);
template<typename T>
inline const std::string& PayloadType_Name(T enum_t_value) {
static_assert(::std::is_same<T, PayloadType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PayloadType_Name.");
return PayloadType_Name(static_cast<PayloadType>(enum_t_value));
}
bool PayloadType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadType* value);
enum PayloadStatus : int {
UNKNOWN_PAYLOAD_STATUS = 0,
SUCCESS = 1,
LOCAL_ERROR = 2,
REMOTE_ERROR = 3,
ENDPOINT_IO_ERROR = 4,
MOVED_TO_NEW_MEDIUM = 5,
CONNECTION_CLOSED = 6,
LOCAL_CANCELLATION = 7,
REMOTE_CANCELLATION = 8,
ENDPOINT_UNENCRYPTED = 9
};
bool PayloadStatus_IsValid(int value);
constexpr PayloadStatus PayloadStatus_MIN = UNKNOWN_PAYLOAD_STATUS;
constexpr PayloadStatus PayloadStatus_MAX = ENDPOINT_UNENCRYPTED;
constexpr int PayloadStatus_ARRAYSIZE = PayloadStatus_MAX + 1;
const std::string& PayloadStatus_Name(PayloadStatus value);
template<typename T>
inline const std::string& PayloadStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, PayloadStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PayloadStatus_Name.");
return PayloadStatus_Name(static_cast<PayloadStatus>(enum_t_value));
}
bool PayloadStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PayloadStatus* value);
enum Bandwidth : int {
BANDWIDTH_UNKNOWN = 0,
BANDWIDTH_24_GHZ = 1,
BANDWIDTH_5_GHZ = 2,
BANDWIDTH_6_GHZ = 3
};
bool Bandwidth_IsValid(int value);
constexpr Bandwidth Bandwidth_MIN = BANDWIDTH_UNKNOWN;
constexpr Bandwidth Bandwidth_MAX = BANDWIDTH_6_GHZ;
constexpr int Bandwidth_ARRAYSIZE = Bandwidth_MAX + 1;
const std::string& Bandwidth_Name(Bandwidth value);
template<typename T>
inline const std::string& Bandwidth_Name(T enum_t_value) {
static_assert(::std::is_same<T, Bandwidth>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Bandwidth_Name.");
return Bandwidth_Name(static_cast<Bandwidth>(enum_t_value));
}
bool Bandwidth_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Bandwidth* value);
enum BandwidthUpgradeResult : int {
UNKNOWN_BANDWIDTH_UPGRADE_RESULT = 0,
UPGRADE_RESULT_SUCCESS = 1,
UPGRADE_RESULT_ERROR = 2,
MEDIUM_ERROR = 3,
PROTOCOL_ERROR = 4,
RESULT_IO_ERROR = 5,
CHANNEL_ERROR = 6,
ALREADY_ON_MEDIUM_ERROR = 7,
UNFINISHED_ERROR = 10,
BLUETOOTH_MEDIUM_ERROR = 11,
WIFI_AWARE_MEDIUM_ERROR = 12,
WIFI_LAN_MEDIUM_ERROR = 13,
WIFI_HOTSPOT_MEDIUM_ERROR = 14,
WIFI_DIRECT_MEDIUM_ERROR = 15,
WEB_RTC_MEDIUM_ERROR = 16,
RESULT_REMOTE_ERROR = 17,
ATTEMPT_SKIPPED = 18
};
bool BandwidthUpgradeResult_IsValid(int value);
constexpr BandwidthUpgradeResult BandwidthUpgradeResult_MIN = UNKNOWN_BANDWIDTH_UPGRADE_RESULT;
constexpr BandwidthUpgradeResult BandwidthUpgradeResult_MAX = ATTEMPT_SKIPPED;
constexpr int BandwidthUpgradeResult_ARRAYSIZE = BandwidthUpgradeResult_MAX + 1;
const std::string& BandwidthUpgradeResult_Name(BandwidthUpgradeResult value);
template<typename T>
inline const std::string& BandwidthUpgradeResult_Name(T enum_t_value) {
static_assert(::std::is_same<T, BandwidthUpgradeResult>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function BandwidthUpgradeResult_Name.");
return BandwidthUpgradeResult_Name(static_cast<BandwidthUpgradeResult>(enum_t_value));
}
bool BandwidthUpgradeResult_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeResult* value);
enum BandwidthUpgradeErrorStage : int {
UNKNOWN_BANDWIDTH_UPGRADE_ERROR_STAGE = 0,
CLIENT_INTRODUCTION = 1,
NETWORK_AVAILABLE = 2,
LAST_WRITE_TO_PRIOR_CHANNEL = 3,
SAFE_TO_CLOSE_PRIOR_CHANNEL = 4,
SOCKET_CREATION = 5,
PRIOR_ENDPOINT_CHANNEL = 6,
UPGRADE_UNFINISHED = 7,
UPGRADE_SUCCESS = 8,
UPGRADE_CANCEL = 9,
WIFI_START_HOTSPOT = 10,
WIFI_LISTEN_INCOMING = 11,
WIFI_CONNECT_TO_HOTSPOT = 12,
WIFI_HOTSPOT_SOCKET_CREATION = 28,
WIFI_LAN_LISTEN_INCOMING = 13,
WIFI_LAN_IP_ADDRESS = 14,
WIFI_LAN_SOCKET_CREATION = 29,
WIFI_LAN_SOCKET_CONNECTION = 15,
BLUETOOTH_LISTEN_INCOMING = 16,
BLUETOOTH_OBTAIN_MAC_ADDRESS = 17,
BLUETOOTH_CONNECT_OUTGOING = 18,
BLUETOOTH_PARSE_MAC_ADDRESS = 19,
BLUETOOTH_SOCKET_CREATION = 30,
WIFI_AWARE_LISTEN_INCOMING = 20,
WIFI_AWARE_PUBLISH = 21,
WIFI_AWARE_SUBSCRIBE = 22,
WIFI_AWARE_CONNECT_TO_NETWORK = 23,
WIFI_AWARE_SOCKET_CREATION = 31,
WIFI_DIRECT_LISTEN_INCOMING = 24,
WIFI_DIRECT_CREATE_GROUP = 25,
WIFI_DIRECT_CONNECT_OUTGOING = 26,
WIFI_DIRECT_PARSE_DEVICE_ADDRESS = 27,
WIFI_DIRECT_SOCKET_CREATION = 32,
WEB_RTC_SOCKET_CREATION = 33,
WEB_RTC_LISTEN_INCOMING = 34
};
bool BandwidthUpgradeErrorStage_IsValid(int value);
constexpr BandwidthUpgradeErrorStage BandwidthUpgradeErrorStage_MIN = UNKNOWN_BANDWIDTH_UPGRADE_ERROR_STAGE;
constexpr BandwidthUpgradeErrorStage BandwidthUpgradeErrorStage_MAX = WEB_RTC_LISTEN_INCOMING;
constexpr int BandwidthUpgradeErrorStage_ARRAYSIZE = BandwidthUpgradeErrorStage_MAX + 1;
const std::string& BandwidthUpgradeErrorStage_Name(BandwidthUpgradeErrorStage value);
template<typename T>
inline const std::string& BandwidthUpgradeErrorStage_Name(T enum_t_value) {
static_assert(::std::is_same<T, BandwidthUpgradeErrorStage>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function BandwidthUpgradeErrorStage_Name.");
return BandwidthUpgradeErrorStage_Name(static_cast<BandwidthUpgradeErrorStage>(enum_t_value));
}
bool BandwidthUpgradeErrorStage_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BandwidthUpgradeErrorStage* value);
enum LogSource : int {
UNSPECIFIED_SOURCE = 0,
LAB_DEVICES = 1,
INTERNAL_DEVICES = 2,
BETA_TESTER_DEVICES = 3,
OEM_DEVICES = 4,
DEBUG_DEVICES = 5
};
bool LogSource_IsValid(int value);
constexpr LogSource LogSource_MIN = UNSPECIFIED_SOURCE;
constexpr LogSource LogSource_MAX = DEBUG_DEVICES;
constexpr int LogSource_ARRAYSIZE = LogSource_MAX + 1;
const std::string& LogSource_Name(LogSource value);
template<typename T>
inline const std::string& LogSource_Name(T enum_t_value) {
static_assert(::std::is_same<T, LogSource>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function LogSource_Name.");
return LogSource_Name(static_cast<LogSource>(enum_t_value));
}
bool LogSource_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LogSource* value);
// ===================================================================
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// @@protoc_insertion_point(namespace_scope)
} // namespace connections
} // namespace proto
} // namespace nearby
} // namespace location
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::location::nearby::proto::connections::EventType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionsStrategy> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::SessionRole> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::Medium> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionTechnology> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionBand> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionRequestResponse> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionAttemptResult> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionAttemptDirection> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::ConnectionAttemptType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::DisconnectionReason> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::PayloadType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::PayloadStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::Bandwidth> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::BandwidthUpgradeResult> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::BandwidthUpgradeErrorStage> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::connections::LogSource> : ::std::true_type {};
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fconnections_5fenums_2eproto
proto/errorcode/error_code_enums.pb.cc
+1601
View File
File diff suppressed because it is too large Load Diff
proto/errorcode/error_code_enums.pb.h
+569
View File
@@ -0,0 +1,569 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: proto/errorcode/error_code_enums.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
PROTOBUF_NAMESPACE_OPEN
PROTOBUF_NAMESPACE_CLOSE
namespace location {
namespace nearby {
namespace errorcode {
namespace proto {
enum ErrorType : int {
UNKNOWN_TYPE = 0,
DEVELOPING = 1,
DEVICE = 2,
SYSTEM = 3,
NETWORK = 4,
OTHERS = 5
};
bool ErrorType_IsValid(int value);
constexpr ErrorType ErrorType_MIN = UNKNOWN_TYPE;
constexpr ErrorType ErrorType_MAX = OTHERS;
constexpr int ErrorType_ARRAYSIZE = ErrorType_MAX + 1;
const std::string& ErrorType_Name(ErrorType value);
template<typename T>
inline const std::string& ErrorType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ErrorType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ErrorType_Name.");
return ErrorType_Name(static_cast<ErrorType>(enum_t_value));
}
bool ErrorType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ErrorType* value);
enum Event : int {
UNKNOWN_EVENT = 0,
START_ADVERTISING = 1,
STOP_ADVERTISING = 2,
START_LISTENING_INCOMING_CONNECTION = 3,
STOP_LISTENING_INCOMING_CONNECTION = 4,
START_DISCOVERING = 5,
STOP_DISCOVERING = 6,
CONNECT = 7,
DISCONNECT = 8,
ACCEPT_CONNECTION = 9,
REJECT_CONNECTION = 10,
SEND_PAYLOAD = 11,
CANCEL_PAYLOAD = 12,
RECEIVE_PAYLOAD = 13
};
bool Event_IsValid(int value);
constexpr Event Event_MIN = UNKNOWN_EVENT;
constexpr Event Event_MAX = RECEIVE_PAYLOAD;
constexpr int Event_ARRAYSIZE = Event_MAX + 1;
const std::string& Event_Name(Event value);
template<typename T>
inline const std::string& Event_Name(T enum_t_value) {
static_assert(::std::is_same<T, Event>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Event_Name.");
return Event_Name(static_cast<Event>(enum_t_value));
}
bool Event_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Event* value);
enum CommonError : int {
UNKNOWN_ERROR = 0,
INVALID_PARAMETER = 1,
MEDIUM_NOT_AVAILABLE = 2,
UNEXPECTED_MEDIUM_STATE = 3,
OUT_OF_RESOURCE = 4,
FLOW_CANCELED = 5,
UNEXPECTED_CALL = 6
};
bool CommonError_IsValid(int value);
constexpr CommonError CommonError_MIN = UNKNOWN_ERROR;
constexpr CommonError CommonError_MAX = UNEXPECTED_CALL;
constexpr int CommonError_ARRAYSIZE = CommonError_MAX + 1;
const std::string& CommonError_Name(CommonError value);
template<typename T>
inline const std::string& CommonError_Name(T enum_t_value) {
static_assert(::std::is_same<T, CommonError>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function CommonError_Name.");
return CommonError_Name(static_cast<CommonError>(enum_t_value));
}
bool CommonError_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CommonError* value);
enum StartAdvertisingError : int {
MULTIPLE_FAST_ADVERTISEMENT_NOT_ALLOWED = 31,
FAST_ADVERTISEMENT_ALREADY_ADVERTISED = 32,
DUPLICATE_ADVERTISING_REQUESTED = 33,
START_GATT_SERVER_FAILED = 34,
BLE_MAX_GATT_ADVERTISEMENT_SLOT_REACHED = 35,
START_LEGACY_ADVERTISING_FAILED = 36,
START_EXTENDED_ADVERTISING_FAILED = 38,
BLUETOOTH_ALREADY_ADVERTISED = 40,
MODIFY_BLUETOOTH_NAME_FAILED = 41,
PERSIST_ORIGINAL_BLUETOOTH_NAME_FAILED = 42,
START_ADVERTISING_FAILED = 43,
SHOULD_ACCEPT_CONNECTIONS_BEFORE_ADVERTISING_ON_WIFI_LAN = 44,
ACQUIRE_WIFI_AWARE_SESSION_FAILED = 45,
UNKNOWN_START_ADVERTISING_ERROR = 46,
AWARE_UPDATE_PUBLISHING_FAILED = 47
};
bool StartAdvertisingError_IsValid(int value);
constexpr StartAdvertisingError StartAdvertisingError_MIN = MULTIPLE_FAST_ADVERTISEMENT_NOT_ALLOWED;
constexpr StartAdvertisingError StartAdvertisingError_MAX = AWARE_UPDATE_PUBLISHING_FAILED;
constexpr int StartAdvertisingError_ARRAYSIZE = StartAdvertisingError_MAX + 1;
const std::string& StartAdvertisingError_Name(StartAdvertisingError value);
template<typename T>
inline const std::string& StartAdvertisingError_Name(T enum_t_value) {
static_assert(::std::is_same<T, StartAdvertisingError>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function StartAdvertisingError_Name.");
return StartAdvertisingError_Name(static_cast<StartAdvertisingError>(enum_t_value));
}
bool StartAdvertisingError_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartAdvertisingError* value);
enum StopAdvertisingError : int {
STOP_ADVERTISING_FAILED = 31,
RESTORE_BLUETOOTH_NAME_FAILED = 32,
STOP_LEGACY_ADVERTISING_FAILED = 33,
STOP_EXTENDED_ADVERTISING_FAILED = 34,
UNKNOWN_STOP_ADVERTISING_ERROR = 35
};
bool StopAdvertisingError_IsValid(int value);
constexpr StopAdvertisingError StopAdvertisingError_MIN = STOP_ADVERTISING_FAILED;
constexpr StopAdvertisingError StopAdvertisingError_MAX = UNKNOWN_STOP_ADVERTISING_ERROR;
constexpr int StopAdvertisingError_ARRAYSIZE = StopAdvertisingError_MAX + 1;
const std::string& StopAdvertisingError_Name(StopAdvertisingError value);
template<typename T>
inline const std::string& StopAdvertisingError_Name(T enum_t_value) {
static_assert(::std::is_same<T, StopAdvertisingError>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function StopAdvertisingError_Name.");
return StopAdvertisingError_Name(static_cast<StopAdvertisingError>(enum_t_value));
}
bool StopAdvertisingError_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopAdvertisingError* value);
enum StartDiscoveringError : int {
DUPLICATE_DISCOVERING_REQUESTED = 31,
START_LEGACY_DISCOVERING_FAILED = 32,
START_EXTENDED_DISCOVERING_FAILED = 33,
START_DISCOVERING_FAILED = 34,
INVALID_TARGET_INFO = 35,
FETCH_ADVERTISEMENT_FAILED = 36,
GATT_FETCH_ADVERTISEMENT_FAILED = 37,
L2CAP_FETCH_ADVERTISEMENT_FAILED = 38,
NOT_AVAILABLE_TO_FETCH_ADVERTISEMENT = 39,
ACQUIRE_WIFI_AWARE_SESSION_FOR_DISCOVERING_FAILED = 40,
UNKNOWN_START_DISCOVERING_ERROR = 41
};
bool StartDiscoveringError_IsValid(int value);
constexpr StartDiscoveringError StartDiscoveringError_MIN = DUPLICATE_DISCOVERING_REQUESTED;
constexpr StartDiscoveringError StartDiscoveringError_MAX = UNKNOWN_START_DISCOVERING_ERROR;
constexpr int StartDiscoveringError_ARRAYSIZE = StartDiscoveringError_MAX + 1;
const std::string& StartDiscoveringError_Name(StartDiscoveringError value);
template<typename T>
inline const std::string& StartDiscoveringError_Name(T enum_t_value) {
static_assert(::std::is_same<T, StartDiscoveringError>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function StartDiscoveringError_Name.");
return StartDiscoveringError_Name(static_cast<StartDiscoveringError>(enum_t_value));
}
bool StartDiscoveringError_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartDiscoveringError* value);
enum StopDiscoveringError : int {
STOP_DISCOVERING_FAILED = 31,
STOP_LEGACY_DISCOVERING_FAILED = 32,
STOP_EXTENDED_DISCOVERING_FAILED = 33,
UNKNOWN_STOP_DISCOVERING_ERROR = 34
};
bool StopDiscoveringError_IsValid(int value);
constexpr StopDiscoveringError StopDiscoveringError_MIN = STOP_DISCOVERING_FAILED;
constexpr StopDiscoveringError StopDiscoveringError_MAX = UNKNOWN_STOP_DISCOVERING_ERROR;
constexpr int StopDiscoveringError_ARRAYSIZE = StopDiscoveringError_MAX + 1;
const std::string& StopDiscoveringError_Name(StopDiscoveringError value);
template<typename T>
inline const std::string& StopDiscoveringError_Name(T enum_t_value) {
static_assert(::std::is_same<T, StopDiscoveringError>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function StopDiscoveringError_Name.");
return StopDiscoveringError_Name(static_cast<StopDiscoveringError>(enum_t_value));
}
bool StopDiscoveringError_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopDiscoveringError* value);
enum StartListeningIncomingConnectionError : int {
DUPLICATE_ACCEPTING_CONNECTION_REQUESTED = 31,
OPEN_GATT_SERVER_FAILED = 32,
ACCEPT_GATT_CONNECTION_FAILED = 33,
ACCEPT_L2CAP_CONNECTION_FAILED = 34,
CREATE_GATT_SERVER_SOCKET_NOT_READY = 35,
ACCEPT_CONNECTION_FAILED = 36,
CREATE_SERVER_SOCKET_FAILED = 37,
UNKNOWN_START_LISTENING_INCOMING_CONNECTION_ERROR = 38,
ACCEPT_SEND_AWARE_L2_MESSAGE_FAILED = 39,
ACCEPT_RECEIVE_AWARE_L2_MESSAGE_FAILED = 40
};
bool StartListeningIncomingConnectionError_IsValid(int value);
constexpr StartListeningIncomingConnectionError StartListeningIncomingConnectionError_MIN = DUPLICATE_ACCEPTING_CONNECTION_REQUESTED;
constexpr StartListeningIncomingConnectionError StartListeningIncomingConnectionError_MAX = ACCEPT_RECEIVE_AWARE_L2_MESSAGE_FAILED;
constexpr int StartListeningIncomingConnectionError_ARRAYSIZE = StartListeningIncomingConnectionError_MAX + 1;
const std::string& StartListeningIncomingConnectionError_Name(StartListeningIncomingConnectionError value);
template<typename T>
inline const std::string& StartListeningIncomingConnectionError_Name(T enum_t_value) {
static_assert(::std::is_same<T, StartListeningIncomingConnectionError>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function StartListeningIncomingConnectionError_Name.");
return StartListeningIncomingConnectionError_Name(static_cast<StartListeningIncomingConnectionError>(enum_t_value));
}
bool StartListeningIncomingConnectionError_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartListeningIncomingConnectionError* value);
enum StopListeningIncomingConnectionError : int {
STOP_ACCEPTING_CONNECTION_FAILED = 31,
UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR = 32
};
bool StopListeningIncomingConnectionError_IsValid(int value);
constexpr StopListeningIncomingConnectionError StopListeningIncomingConnectionError_MIN = STOP_ACCEPTING_CONNECTION_FAILED;
constexpr StopListeningIncomingConnectionError StopListeningIncomingConnectionError_MAX = UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR;
constexpr int StopListeningIncomingConnectionError_ARRAYSIZE = StopListeningIncomingConnectionError_MAX + 1;
const std::string& StopListeningIncomingConnectionError_Name(StopListeningIncomingConnectionError value);
template<typename T>
inline const std::string& StopListeningIncomingConnectionError_Name(T enum_t_value) {
static_assert(::std::is_same<T, StopListeningIncomingConnectionError>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function StopListeningIncomingConnectionError_Name.");
return StopListeningIncomingConnectionError_Name(static_cast<StopListeningIncomingConnectionError>(enum_t_value));
}
bool StopListeningIncomingConnectionError_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopListeningIncomingConnectionError* value);
enum ConnectError : int {
UNEXPECT_TARGET_LOST = 31,
ESTABLISH_GATT_CONNECTION_FAILED = 32,
ESTABLISH_L2CAP_CONNECTION_FAILED = 33,
INVALID_MAC_ADDRESS = 34,
SLEEP_BEFORE_CONNECT_GATT_INTERRUPTED = 35,
SLEEP_AFTER_GATT_CONNECTED_INTERRUPTED = 36,
REQUEST_GATT_CONNECTION_PRIORITY_FAILED = 37,
L2CAP_SWITCH_TO_DATA_TRANSFERRING_FAILED = 38,
GATT_SWITCH_TO_DATA_TRANSFERRING_FAILED = 39,
ESTABLISH_CONNECTION_FAILED = 40,
DUPLICATE_CONNECTION_REQUESTED = 41,
CONNECTION_LOST = 42,
CONNECT_TO_NETWORK_FAILED = 43,
UNKNOWN_CONNECT_ERROR = 44,
CONNECT_SEND_AWARE_L2_MESSAGE_FAILED = 45,
CONNECT_READ_AWARE_L2_MESSAGE_FAILED = 46
};
bool ConnectError_IsValid(int value);
constexpr ConnectError ConnectError_MIN = UNEXPECT_TARGET_LOST;
constexpr ConnectError ConnectError_MAX = CONNECT_READ_AWARE_L2_MESSAGE_FAILED;
constexpr int ConnectError_ARRAYSIZE = ConnectError_MAX + 1;
const std::string& ConnectError_Name(ConnectError value);
template<typename T>
inline const std::string& ConnectError_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConnectError>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConnectError_Name.");
return ConnectError_Name(static_cast<ConnectError>(enum_t_value));
}
bool ConnectError_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectError* value);
enum DisconnectError : int {
DISCONNECT_NETWORK_FAILED = 31,
UNKNOWN_DISCONNECT_ERROR = 32
};
bool DisconnectError_IsValid(int value);
constexpr DisconnectError DisconnectError_MIN = DISCONNECT_NETWORK_FAILED;
constexpr DisconnectError DisconnectError_MAX = UNKNOWN_DISCONNECT_ERROR;
constexpr int DisconnectError_ARRAYSIZE = DisconnectError_MAX + 1;
const std::string& DisconnectError_Name(DisconnectError value);
template<typename T>
inline const std::string& DisconnectError_Name(T enum_t_value) {
static_assert(::std::is_same<T, DisconnectError>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DisconnectError_Name.");
return DisconnectError_Name(static_cast<DisconnectError>(enum_t_value));
}
bool DisconnectError_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisconnectError* value);
enum Description : int {
UNKNOWN = 0,
NULL_SERVICE_ID = 1,
NULL_ADVERTISEMENT_BYTES = 2,
CONNECTIONS_FEATURE_DISABLED = 3,
STALE_SDK_VERSION = 4,
FEATURE_BLUETOOTH_NOT_SUPPORTED = 5,
FEATURE_BLUETOOTH_LE_NOT_SUPPORTED = 6,
NULL_BLUETOOTH_MANAGER = 7,
NULL_BLUETOOTH_ADAPTER = 8,
INVALID_FAST_PAIR_MODEL_ID = 9,
INVALID_FAST_ADVERTISEMENT_DATA = 10,
INVALID_ADVERTISEMENT_HEADER_DATA = 11,
INVALID_REGULAR_ADVERTISEMENT_DATA = 12,
NULL_BLUETOOTH_LE_ADVERTISER_COMPAT = 13,
ADVERTISE_FAILED_ALREADY_STARTED = 14,
ADVERTISE_FAILED_DATA_TOO_LARGE = 15,
ADVERTISE_FAILED_FEATURE_UNSUPPORTED = 16,
ADVERTISE_FAILED_INTERNAL_ERROR = 17,
ADVERTISE_FAILED_TOO_MANY_ADVERTISERS = 18,
INTERRUPTED_EXCEPTION = 19,
EXECUTION_EXCEPTION = 20,
NULL_BLUETOOTH_DEVICE_NAME = 21,
SET_SCAN_MODE_FAILED = 22,
INVOKE_API_FAILED = 23,
TIMEOUT = 24,
NULL_NFC_TAG = 25,
FEATURE_NFC_NOT_SUPPORTED = 26,
FEATURE_NFC_HOST_CARD_EMULATION_NOT_SUPPORTED = 27,
MULTICAST_NOT_SUPPORTED = 30,
NSD_NOT_ENABLED = 31,
INVALID_PORT_NUMBER = 32,
NULL_SERVICE_NAME = 33,
NULL_SERVICE_TYPE = 34,
WITHOUT_CONNECTED_WIFI_NETWORK = 35,
FEATURE_WIFI_AWARE_NOT_SUPPORTED = 36,
NULL_CONNECTIVITY_MANAGER = 37,
NULL_WIFI_AWARE_MANAGER = 38,
STALE_ANDROID_VERSION = 39,
NULL_SERVICE_INFO = 40,
NULL_WORK_SOURCE = 41,
NULL_CALLBACK = 42,
NULL_BLUETOOTH_LE_SCANNER_COMPAT = 43,
EMPTY_WORK_SOURCE_CACHE = 44,
SCAN_FAILED_ALREADY_STARTED = 45,
SCAN_FAILED_APPLICATION_REGISTRATION_FAILED = 46,
SCAN_FAILED_INTERNAL_ERROR = 47,
SCAN_FAILED_FEATURE_UNSUPPORTED = 48,
SCAN_FAILED_BLUETOOTH_DISABLED = 49,
SCAN_FILTERS_NOT_ALLOWED_FOR_LOCATION = 50,
BLUETOOTH_SCAN_REJUVENATE_FAILED = 51,
NULL_BLE_PERIPHERAL = 52,
NULL_BLUETOOTH_GATT = 53,
UNEXPECTED_BLUETOOTH_STATE = 54,
REMOTE_EXCEPTION = 55,
INVALID_BLUETOOTH_SOCKET_STATE_BEFORE_CONNECT = 56,
BLUETOOTH_SOCKET_CLOSED_AFTER_CONNECTED = 57,
INVALID_BLUETOOTH_CHANNEL = 58,
NULL_BLUETOOTH_DEVICE = 59,
NULL_BLUETOOTH_PROXY = 60,
INVALID_PACKET_LENGTH = 61,
INVALID_PACKET_BYTES = 62,
UNEXPECTED_EOF_EXCEPTION = 63,
SOCKET_CLOSED_OR_TIMEOUT = 64,
INVALID_IPV4_ADDRESS = 65,
INVALID_IPV6_ADDRESS = 66,
NULL_ADDRESS = 67,
INVALID_VERSION = 68,
SET_CONNECTION_PRIORITY_FAILED = 69,
SET_CONNECTION_PRIORITY_INTERRUPTED = 70,
UNKNOWN_IO_EXCEPTION = 71,
READ_CHARACTERISTIC_FAILED = 72,
WIFI_HOTSPOT_ENABLED = 73,
AWARE_UNAVAILABLE = 74,
IN_BLACK_LIST = 75,
FEATURE_WIFI_NOT_SUPPORTED = 76,
NULL_WIFI_MANAGER = 77,
SOCKET_CLOSED = 78,
SOCKET_ALREADY_CONNECTED = 79,
NFC_TECH_NOT_SUPPORTED = 80,
NFC_SERVICE_DIED = 81,
BIND_NFC_SERVICE_FAILED = 82,
NFC_CREATE_SOCKET_FAILED = 83,
NULL_WIFI_AWARE_PEER = 84,
NETWORK_ALREADY_JOINED = 85,
JOIN_AWARE_NETWORK_CANCELLED = 86,
NETWORK_UNAVAILABLE = 87,
WITHOUT_ACTIVE_AWARE_NETWORK = 88,
WITHOUT_JOINED_AWARE_NETWORK = 89,
CONNET_TO_SOCKET_CANCELLED = 90,
NULL_SSID = 91,
NULL_PASSWORD = 92,
FEATURE_WIFI_DIRECT_NOT_SUPPORTED = 93,
NULL_WIFI_P2P_MANAGER = 94,
P2P_GROUP_FORMED = 95,
ACQUIRE_P2P_CHANNEL_FAILED = 96,
P2P_UNSUPPORTED = 97,
INTERNAL_ERROR = 98,
BUSY = 99,
REFLECTION_ERROR = 100,
NETWORK_ERROR_EHOSTUNREACH = 101,
NETWORK_ERROR_ENETUNREACH = 102,
ADD_NETWORK_FAILED = 103,
UPDATE_NETWORK_FAILED = 104,
ALREADY_IN_PROGRESS = 105,
INVALID_ARGS = 106,
NOT_AUTHORIZED = 107,
INVALID_NETWORK_ID = 108,
WIFI_MANAGER_ENABLE_NETWORK_FAILED = 109,
WIFI_MANAGER_RECONNECT_FAILED = 110,
WITHOUT_ACTIVE_NETWORK = 111,
WEBRTC_CONNECTION_FLOW_EXIST = 112,
NULL_DROID_GUARD_RESULT = 113,
TACHYON_SIGNALING_MESSENGER_EXIST = 114,
TACHYON_ALREADY_START_RECEIVE_MESSAGE = 115,
TACHYON_RECEIVE_MESSAGE_FAILED = 116,
TACHYON_RECEIVE_MESSAGE_INTERRUPTED = 117,
TACHYON_RECEIVE_MESSAGE_EXECUTION_EXCEPTION = 118,
TACHYON_RECEIVE_MESSAGE_TIMEOUT = 119,
TACHYON_RECEIVE_MESSAGE_AUTH_EXCEPTION = 120,
TACHYON_RECEIVE_MESSAGE_STATUS_EXCEPTION = 121,
TACHYON_SEND_MESSAGE_AUTH_EXCEPTION = 122,
TACHYON_SEND_MESSAGE_STATUS_EXCEPTION = 123,
TACHYON_GET_ICE_SERVER_AUTH_EXCEPTION = 124,
TACHYON_GET_ICE_SERVER_STATUS_EXCEPTION = 125,
EMPTY_TACHYON_ICE_SERVER = 126,
POTENTIAL_WEBRTC_LIB_LOADING_FAILURE = 127,
UNEXPECTED_GATT_DESCRIPTOR = 128,
FAIL_TO_RECEIVE_L2CAP_PACKET = 129,
WITHOUT_PSM_VALUE = 130,
SOCKET_BIND_LISTEN_FAILED = 131,
UNEXPECTED_PACKET_CONTENT = 132,
UNREGISTER_NSD_MANAGER_FAILED = 133,
PUBLISH_EMPTY_ADVERTISEMENT_FAILED = 134,
BLUETOOTH_SOCKET_NOT_IN_LISTENING_STATE = 135,
INVALID_BLUETOOTH_SOCKET_SIGNAL_SIZE = 136,
INVALID_BLUETOOTH_SOCKET_SIGNAL_STATUS = 137,
GET_ADDRESS_FAILED = 138,
NULL_LOCAL_ADDRESS = 139,
IS_LOOPBACK_ADDRESS = 140,
SOCKET_NOT_BOUND = 141,
INVALID_REMOTE_ADDRESS = 142,
SOCKET_ALREADY_BOUND = 143,
HOTSPOT_NOT_STARTED = 144,
WEBRTC_ALREADY_INITIALIZED = 145,
INVALID_WEBRTC_STATE = 146,
NULL_DATA_CHANNEL = 147,
CREATE_OFFER_FAILED = 148,
CLOSE_SERVER_SOCKET_FAILED = 149,
WIFI_AWARE_STARTED = 150,
AWARE_PUBLISH_SESSION_RAN_OUT = 151,
AWARE_SUBSCRIBE_SESSION_RAN_OUT = 152,
AWARE_DATA_PATH_RAN_OUT = 153,
WIFI_SIGNAL_STRENGTH_POOR = 154,
POTENTIAL_SRD_ISSUE = 155,
AWARE_L2_MESSAGE_HOST_NETWORK_ERROR = 156,
AWARE_L2_MESSAGE_NETWORK_AVAILABLE_ERROR = 157,
AWARE_L2_MESSAGE_IP_AVAILABLE_ERROR = 158,
AWARE_L2_MESSAGE_CANCELLATION_RECEIVED = 159,
TIE_BREAK_LOSER = 160,
SERVER_SOCKET_UNAVAILABLE = 161,
HOSTED_NETWORK_UNAVAILABLE = 162,
AWARE_UPDATE_PUBLISHING_CONFIG_FAILED = 163,
L2CAP_UNAVAILABLE = 164,
ALREADY_HAS_GATT_CONNECTION = 165,
UNSUPPORTED_DEVICE_TYPE = 166,
UNSUPPORTED_DEVICE_TYPE_CHROME_OS = 167,
UNSUPPORTED_DEVICE_TYPE_AUTO = 168,
UNSUPPORTED_DEVICE_TYPE_TV = 169,
UNSUPPORTED_DEVICE_TYPE_WEAR = 170,
NULL_MESSAGE = 171
};
bool Description_IsValid(int value);
constexpr Description Description_MIN = UNKNOWN;
constexpr Description Description_MAX = NULL_MESSAGE;
constexpr int Description_ARRAYSIZE = Description_MAX + 1;
const std::string& Description_Name(Description value);
template<typename T>
inline const std::string& Description_Name(T enum_t_value) {
static_assert(::std::is_same<T, Description>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Description_Name.");
return Description_Name(static_cast<Description>(enum_t_value));
}
bool Description_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Description* value);
// ===================================================================
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// @@protoc_insertion_point(namespace_scope)
} // namespace proto
} // namespace errorcode
} // namespace nearby
} // namespace location
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::ErrorType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::Event> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::CommonError> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StartAdvertisingError> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StopAdvertisingError> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StartDiscoveringError> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StopDiscoveringError> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StartListeningIncomingConnectionError> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::StopListeningIncomingConnectionError> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::ConnectError> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::DisconnectError> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::Description> : ::std::true_type {};
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
proto/mediums/ble_frames.pb.cc
+1271
View File
File diff suppressed because it is too large Load Diff
proto/mediums/ble_frames.pb.h
+1438
View File
File diff suppressed because it is too large Load Diff
proto/mediums/nfc_frames.pb.cc
+646
View File
@@ -0,0 +1,646 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: proto/mediums/nfc_frames.proto
#include "proto/mediums/nfc_frames.pb.h"
#include <algorithm>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
PROTOBUF_PRAGMA_INIT_SEG
namespace location {
namespace nearby {
namespace mediums {
constexpr AdvertisementData::AdvertisementData(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: tag_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, public_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct AdvertisementDataDefaultTypeInternal {
constexpr AdvertisementDataDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~AdvertisementDataDefaultTypeInternal() {}
union {
AdvertisementData _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AdvertisementDataDefaultTypeInternal _AdvertisementData_default_instance_;
constexpr AdvertisementRequest::AdvertisementRequest(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: service_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, endpoint_id_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, public_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct AdvertisementRequestDefaultTypeInternal {
constexpr AdvertisementRequestDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~AdvertisementRequestDefaultTypeInternal() {}
union {
AdvertisementRequest _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AdvertisementRequestDefaultTypeInternal _AdvertisementRequest_default_instance_;
} // namespace mediums
} // namespace nearby
} // namespace location
namespace location {
namespace nearby {
namespace mediums {
// ===================================================================
class AdvertisementData::_Internal {
public:
using HasBits = decltype(std::declval<AdvertisementData>()._has_bits_);
static void set_has_tag(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_public_key(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
};
AdvertisementData::AdvertisementData(::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.mediums.AdvertisementData)
}
AdvertisementData::AdvertisementData(const AdvertisementData& from)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
tag_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_tag()) {
tag_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_tag(),
GetArenaForAllocation());
}
public_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_public_key()) {
public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_public_key(),
GetArenaForAllocation());
}
// @@protoc_insertion_point(copy_constructor:location.nearby.mediums.AdvertisementData)
}
inline void AdvertisementData::SharedCtor() {
tag_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
tag_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
public_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}
AdvertisementData::~AdvertisementData() {
// @@protoc_insertion_point(destructor:location.nearby.mediums.AdvertisementData)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<std::string>();
}
inline void AdvertisementData::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
tag_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
public_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
void AdvertisementData::ArenaDtor(void* object) {
AdvertisementData* _this = reinterpret_cast< AdvertisementData* >(object);
(void)_this;
}
void AdvertisementData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AdvertisementData::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void AdvertisementData::Clear() {
// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.AdvertisementData)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
tag_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000002u) {
public_key_.ClearNonDefaultToEmpty();
}
}
_has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
}
const char* AdvertisementData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional bytes tag = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
auto str = _internal_mutable_tag();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional bytes public_key = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
auto str = _internal_mutable_public_key();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<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* AdvertisementData::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.AdvertisementData)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
// optional bytes tag = 1;
if (cached_has_bits & 0x00000001u) {
target = stream->WriteBytesMaybeAliased(
1, this->_internal_tag(), target);
}
// optional bytes public_key = 2;
if (cached_has_bits & 0x00000002u) {
target = stream->WriteBytesMaybeAliased(
2, this->_internal_public_key(), 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.mediums.AdvertisementData)
return target;
}
size_t AdvertisementData::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.AdvertisementData)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000003u) {
// optional bytes tag = 1;
if (cached_has_bits & 0x00000001u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
this->_internal_tag());
}
// optional bytes public_key = 2;
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
this->_internal_public_key());
}
}
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 AdvertisementData::CheckTypeAndMergeFrom(
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AdvertisementData*>(
&from));
}
void AdvertisementData::MergeFrom(const AdvertisementData& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.AdvertisementData)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x00000003u) {
if (cached_has_bits & 0x00000001u) {
_internal_set_tag(from._internal_tag());
}
if (cached_has_bits & 0x00000002u) {
_internal_set_public_key(from._internal_public_key());
}
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
void AdvertisementData::CopyFrom(const AdvertisementData& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.AdvertisementData)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool AdvertisementData::IsInitialized() const {
return true;
}
void AdvertisementData::InternalSwap(AdvertisementData* other) {
using std::swap;
auto* lhs_arena = GetArenaForAllocation();
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&tag_, lhs_arena,
&other->tag_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&public_key_, lhs_arena,
&other->public_key_, rhs_arena
);
}
std::string AdvertisementData::GetTypeName() const {
return "location.nearby.mediums.AdvertisementData";
}
// ===================================================================
class AdvertisementRequest::_Internal {
public:
using HasBits = decltype(std::declval<AdvertisementRequest>()._has_bits_);
static void set_has_service_id(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_endpoint_id(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
static void set_has_public_key(HasBits* has_bits) {
(*has_bits)[0] |= 4u;
}
};
AdvertisementRequest::AdvertisementRequest(::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.mediums.AdvertisementRequest)
}
AdvertisementRequest::AdvertisementRequest(const AdvertisementRequest& from)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
service_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
service_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_service_id()) {
service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_service_id(),
GetArenaForAllocation());
}
endpoint_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_endpoint_id()) {
endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_endpoint_id(),
GetArenaForAllocation());
}
public_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_public_key()) {
public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_public_key(),
GetArenaForAllocation());
}
// @@protoc_insertion_point(copy_constructor:location.nearby.mediums.AdvertisementRequest)
}
inline void AdvertisementRequest::SharedCtor() {
service_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
service_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
endpoint_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
public_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}
AdvertisementRequest::~AdvertisementRequest() {
// @@protoc_insertion_point(destructor:location.nearby.mediums.AdvertisementRequest)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<std::string>();
}
inline void AdvertisementRequest::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
service_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
endpoint_id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
public_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
void AdvertisementRequest::ArenaDtor(void* object) {
AdvertisementRequest* _this = reinterpret_cast< AdvertisementRequest* >(object);
(void)_this;
}
void AdvertisementRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void AdvertisementRequest::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void AdvertisementRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.AdvertisementRequest)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000007u) {
if (cached_has_bits & 0x00000001u) {
service_id_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000002u) {
endpoint_id_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000004u) {
public_key_.ClearNonDefaultToEmpty();
}
}
_has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
}
const char* AdvertisementRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional string service_id = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
auto str = _internal_mutable_service_id();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional string endpoint_id = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
auto str = _internal_mutable_endpoint_id();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional bytes public_key = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
auto str = _internal_mutable_public_key();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<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* AdvertisementRequest::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.AdvertisementRequest)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
// optional string service_id = 1;
if (cached_has_bits & 0x00000001u) {
target = stream->WriteStringMaybeAliased(
1, this->_internal_service_id(), target);
}
// optional string endpoint_id = 2;
if (cached_has_bits & 0x00000002u) {
target = stream->WriteStringMaybeAliased(
2, this->_internal_endpoint_id(), target);
}
// optional bytes public_key = 3;
if (cached_has_bits & 0x00000004u) {
target = stream->WriteBytesMaybeAliased(
3, this->_internal_public_key(), 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.mediums.AdvertisementRequest)
return target;
}
size_t AdvertisementRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.AdvertisementRequest)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000007u) {
// optional string service_id = 1;
if (cached_has_bits & 0x00000001u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_service_id());
}
// optional string endpoint_id = 2;
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_endpoint_id());
}
// optional bytes public_key = 3;
if (cached_has_bits & 0x00000004u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
this->_internal_public_key());
}
}
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 AdvertisementRequest::CheckTypeAndMergeFrom(
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const AdvertisementRequest*>(
&from));
}
void AdvertisementRequest::MergeFrom(const AdvertisementRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.AdvertisementRequest)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x00000007u) {
if (cached_has_bits & 0x00000001u) {
_internal_set_service_id(from._internal_service_id());
}
if (cached_has_bits & 0x00000002u) {
_internal_set_endpoint_id(from._internal_endpoint_id());
}
if (cached_has_bits & 0x00000004u) {
_internal_set_public_key(from._internal_public_key());
}
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
void AdvertisementRequest::CopyFrom(const AdvertisementRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.AdvertisementRequest)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool AdvertisementRequest::IsInitialized() const {
return true;
}
void AdvertisementRequest::InternalSwap(AdvertisementRequest* other) {
using std::swap;
auto* lhs_arena = GetArenaForAllocation();
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&service_id_, lhs_arena,
&other->service_id_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&endpoint_id_, lhs_arena,
&other->endpoint_id_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&public_key_, lhs_arena,
&other->public_key_, rhs_arena
);
}
std::string AdvertisementRequest::GetTypeName() const {
return "location.nearby.mediums.AdvertisementRequest";
}
// @@protoc_insertion_point(namespace_scope)
} // namespace mediums
} // namespace nearby
} // namespace location
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::location::nearby::mediums::AdvertisementData* Arena::CreateMaybeMessage< ::location::nearby::mediums::AdvertisementData >(Arena* arena) {
return Arena::CreateMessageInternal< ::location::nearby::mediums::AdvertisementData >(arena);
}
template<> PROTOBUF_NOINLINE ::location::nearby::mediums::AdvertisementRequest* Arena::CreateMaybeMessage< ::location::nearby::mediums::AdvertisementRequest >(Arena* arena) {
return Arena::CreateMessageInternal< ::location::nearby::mediums::AdvertisementRequest >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
proto/mediums/nfc_frames.pb.h
+802
View File
@@ -0,0 +1,802 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: proto/mediums/nfc_frames.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fmediums_2fnfc_5fframes_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fmediums_2fnfc_5fframes_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_proto_2fmediums_2fnfc_5fframes_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2fmediums_2fnfc_5fframes_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
namespace location {
namespace nearby {
namespace mediums {
class AdvertisementData;
struct AdvertisementDataDefaultTypeInternal;
extern AdvertisementDataDefaultTypeInternal _AdvertisementData_default_instance_;
class AdvertisementRequest;
struct AdvertisementRequestDefaultTypeInternal;
extern AdvertisementRequestDefaultTypeInternal _AdvertisementRequest_default_instance_;
} // namespace mediums
} // namespace nearby
} // namespace location
PROTOBUF_NAMESPACE_OPEN
template<> ::location::nearby::mediums::AdvertisementData* Arena::CreateMaybeMessage<::location::nearby::mediums::AdvertisementData>(Arena*);
template<> ::location::nearby::mediums::AdvertisementRequest* Arena::CreateMaybeMessage<::location::nearby::mediums::AdvertisementRequest>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace location {
namespace nearby {
namespace mediums {
// ===================================================================
class AdvertisementData final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.AdvertisementData) */ {
public:
inline AdvertisementData() : AdvertisementData(nullptr) {}
~AdvertisementData() override;
explicit constexpr AdvertisementData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AdvertisementData(const AdvertisementData& from);
AdvertisementData(AdvertisementData&& from) noexcept
: AdvertisementData() {
*this = ::std::move(from);
}
inline AdvertisementData& operator=(const AdvertisementData& from) {
CopyFrom(from);
return *this;
}
inline AdvertisementData& operator=(AdvertisementData&& 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 AdvertisementData& default_instance() {
return *internal_default_instance();
}
static inline const AdvertisementData* internal_default_instance() {
return reinterpret_cast<const AdvertisementData*>(
&_AdvertisementData_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(AdvertisementData& a, AdvertisementData& b) {
a.Swap(&b);
}
inline void Swap(AdvertisementData* 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(AdvertisementData* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AdvertisementData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AdvertisementData>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const AdvertisementData& from);
void MergeFrom(const AdvertisementData& 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(AdvertisementData* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "location.nearby.mediums.AdvertisementData";
}
protected:
explicit AdvertisementData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kTagFieldNumber = 1,
kPublicKeyFieldNumber = 2,
};
// optional bytes tag = 1;
bool has_tag() const;
private:
bool _internal_has_tag() const;
public:
void clear_tag();
const std::string& tag() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_tag(ArgT0&& arg0, ArgT... args);
std::string* mutable_tag();
PROTOBUF_NODISCARD std::string* release_tag();
void set_allocated_tag(std::string* tag);
private:
const std::string& _internal_tag() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_tag(const std::string& value);
std::string* _internal_mutable_tag();
public:
// optional bytes public_key = 2;
bool has_public_key() const;
private:
bool _internal_has_public_key() const;
public:
void clear_public_key();
const std::string& public_key() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_public_key(ArgT0&& arg0, ArgT... args);
std::string* mutable_public_key();
PROTOBUF_NODISCARD std::string* release_public_key();
void set_allocated_public_key(std::string* public_key);
private:
const std::string& _internal_public_key() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
std::string* _internal_mutable_public_key();
public:
// @@protoc_insertion_point(class_scope:location.nearby.mediums.AdvertisementData)
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::internal::ArenaStringPtr tag_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
friend struct ::TableStruct_proto_2fmediums_2fnfc_5fframes_2eproto;
};
// -------------------------------------------------------------------
class AdvertisementRequest final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.AdvertisementRequest) */ {
public:
inline AdvertisementRequest() : AdvertisementRequest(nullptr) {}
~AdvertisementRequest() override;
explicit constexpr AdvertisementRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
AdvertisementRequest(const AdvertisementRequest& from);
AdvertisementRequest(AdvertisementRequest&& from) noexcept
: AdvertisementRequest() {
*this = ::std::move(from);
}
inline AdvertisementRequest& operator=(const AdvertisementRequest& from) {
CopyFrom(from);
return *this;
}
inline AdvertisementRequest& operator=(AdvertisementRequest&& 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 AdvertisementRequest& default_instance() {
return *internal_default_instance();
}
static inline const AdvertisementRequest* internal_default_instance() {
return reinterpret_cast<const AdvertisementRequest*>(
&_AdvertisementRequest_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(AdvertisementRequest& a, AdvertisementRequest& b) {
a.Swap(&b);
}
inline void Swap(AdvertisementRequest* 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(AdvertisementRequest* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
AdvertisementRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<AdvertisementRequest>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const AdvertisementRequest& from);
void MergeFrom(const AdvertisementRequest& 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(AdvertisementRequest* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "location.nearby.mediums.AdvertisementRequest";
}
protected:
explicit AdvertisementRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kServiceIdFieldNumber = 1,
kEndpointIdFieldNumber = 2,
kPublicKeyFieldNumber = 3,
};
// optional string service_id = 1;
bool has_service_id() const;
private:
bool _internal_has_service_id() const;
public:
void clear_service_id();
const std::string& service_id() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_service_id(ArgT0&& arg0, ArgT... args);
std::string* mutable_service_id();
PROTOBUF_NODISCARD std::string* release_service_id();
void set_allocated_service_id(std::string* service_id);
private:
const std::string& _internal_service_id() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id(const std::string& value);
std::string* _internal_mutable_service_id();
public:
// optional string endpoint_id = 2;
bool has_endpoint_id() const;
private:
bool _internal_has_endpoint_id() const;
public:
void clear_endpoint_id();
const std::string& endpoint_id() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_endpoint_id(ArgT0&& arg0, ArgT... args);
std::string* mutable_endpoint_id();
PROTOBUF_NODISCARD std::string* release_endpoint_id();
void set_allocated_endpoint_id(std::string* endpoint_id);
private:
const std::string& _internal_endpoint_id() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_endpoint_id(const std::string& value);
std::string* _internal_mutable_endpoint_id();
public:
// optional bytes public_key = 3;
bool has_public_key() const;
private:
bool _internal_has_public_key() const;
public:
void clear_public_key();
const std::string& public_key() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_public_key(ArgT0&& arg0, ArgT... args);
std::string* mutable_public_key();
PROTOBUF_NODISCARD std::string* release_public_key();
void set_allocated_public_key(std::string* public_key);
private:
const std::string& _internal_public_key() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
std::string* _internal_mutable_public_key();
public:
// @@protoc_insertion_point(class_scope:location.nearby.mediums.AdvertisementRequest)
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::internal::ArenaStringPtr service_id_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr endpoint_id_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
friend struct ::TableStruct_proto_2fmediums_2fnfc_5fframes_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// AdvertisementData
// optional bytes tag = 1;
inline bool AdvertisementData::_internal_has_tag() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool AdvertisementData::has_tag() const {
return _internal_has_tag();
}
inline void AdvertisementData::clear_tag() {
tag_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& AdvertisementData::tag() const {
// @@protoc_insertion_point(field_get:location.nearby.mediums.AdvertisementData.tag)
return _internal_tag();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AdvertisementData::set_tag(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
tag_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:location.nearby.mediums.AdvertisementData.tag)
}
inline std::string* AdvertisementData::mutable_tag() {
std::string* _s = _internal_mutable_tag();
// @@protoc_insertion_point(field_mutable:location.nearby.mediums.AdvertisementData.tag)
return _s;
}
inline const std::string& AdvertisementData::_internal_tag() const {
return tag_.Get();
}
inline void AdvertisementData::_internal_set_tag(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
tag_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AdvertisementData::_internal_mutable_tag() {
_has_bits_[0] |= 0x00000001u;
return tag_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AdvertisementData::release_tag() {
// @@protoc_insertion_point(field_release:location.nearby.mediums.AdvertisementData.tag)
if (!_internal_has_tag()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = tag_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (tag_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
tag_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AdvertisementData::set_allocated_tag(std::string* tag) {
if (tag != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
tag_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tag,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (tag_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
tag_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.AdvertisementData.tag)
}
// optional bytes public_key = 2;
inline bool AdvertisementData::_internal_has_public_key() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool AdvertisementData::has_public_key() const {
return _internal_has_public_key();
}
inline void AdvertisementData::clear_public_key() {
public_key_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& AdvertisementData::public_key() const {
// @@protoc_insertion_point(field_get:location.nearby.mediums.AdvertisementData.public_key)
return _internal_public_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AdvertisementData::set_public_key(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:location.nearby.mediums.AdvertisementData.public_key)
}
inline std::string* AdvertisementData::mutable_public_key() {
std::string* _s = _internal_mutable_public_key();
// @@protoc_insertion_point(field_mutable:location.nearby.mediums.AdvertisementData.public_key)
return _s;
}
inline const std::string& AdvertisementData::_internal_public_key() const {
return public_key_.Get();
}
inline void AdvertisementData::_internal_set_public_key(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AdvertisementData::_internal_mutable_public_key() {
_has_bits_[0] |= 0x00000002u;
return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AdvertisementData::release_public_key() {
// @@protoc_insertion_point(field_release:location.nearby.mediums.AdvertisementData.public_key)
if (!_internal_has_public_key()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AdvertisementData::set_allocated_public_key(std::string* public_key) {
if (public_key != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.AdvertisementData.public_key)
}
// -------------------------------------------------------------------
// AdvertisementRequest
// optional string service_id = 1;
inline bool AdvertisementRequest::_internal_has_service_id() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool AdvertisementRequest::has_service_id() const {
return _internal_has_service_id();
}
inline void AdvertisementRequest::clear_service_id() {
service_id_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& AdvertisementRequest::service_id() const {
// @@protoc_insertion_point(field_get:location.nearby.mediums.AdvertisementRequest.service_id)
return _internal_service_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AdvertisementRequest::set_service_id(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:location.nearby.mediums.AdvertisementRequest.service_id)
}
inline std::string* AdvertisementRequest::mutable_service_id() {
std::string* _s = _internal_mutable_service_id();
// @@protoc_insertion_point(field_mutable:location.nearby.mediums.AdvertisementRequest.service_id)
return _s;
}
inline const std::string& AdvertisementRequest::_internal_service_id() const {
return service_id_.Get();
}
inline void AdvertisementRequest::_internal_set_service_id(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AdvertisementRequest::_internal_mutable_service_id() {
_has_bits_[0] |= 0x00000001u;
return service_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AdvertisementRequest::release_service_id() {
// @@protoc_insertion_point(field_release:location.nearby.mediums.AdvertisementRequest.service_id)
if (!_internal_has_service_id()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = service_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (service_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
service_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AdvertisementRequest::set_allocated_service_id(std::string* service_id) {
if (service_id != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
service_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (service_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
service_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.AdvertisementRequest.service_id)
}
// optional string endpoint_id = 2;
inline bool AdvertisementRequest::_internal_has_endpoint_id() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool AdvertisementRequest::has_endpoint_id() const {
return _internal_has_endpoint_id();
}
inline void AdvertisementRequest::clear_endpoint_id() {
endpoint_id_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& AdvertisementRequest::endpoint_id() const {
// @@protoc_insertion_point(field_get:location.nearby.mediums.AdvertisementRequest.endpoint_id)
return _internal_endpoint_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AdvertisementRequest::set_endpoint_id(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:location.nearby.mediums.AdvertisementRequest.endpoint_id)
}
inline std::string* AdvertisementRequest::mutable_endpoint_id() {
std::string* _s = _internal_mutable_endpoint_id();
// @@protoc_insertion_point(field_mutable:location.nearby.mediums.AdvertisementRequest.endpoint_id)
return _s;
}
inline const std::string& AdvertisementRequest::_internal_endpoint_id() const {
return endpoint_id_.Get();
}
inline void AdvertisementRequest::_internal_set_endpoint_id(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
endpoint_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AdvertisementRequest::_internal_mutable_endpoint_id() {
_has_bits_[0] |= 0x00000002u;
return endpoint_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AdvertisementRequest::release_endpoint_id() {
// @@protoc_insertion_point(field_release:location.nearby.mediums.AdvertisementRequest.endpoint_id)
if (!_internal_has_endpoint_id()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = endpoint_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (endpoint_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AdvertisementRequest::set_allocated_endpoint_id(std::string* endpoint_id) {
if (endpoint_id != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
endpoint_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), endpoint_id,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (endpoint_id_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
endpoint_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.AdvertisementRequest.endpoint_id)
}
// optional bytes public_key = 3;
inline bool AdvertisementRequest::_internal_has_public_key() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool AdvertisementRequest::has_public_key() const {
return _internal_has_public_key();
}
inline void AdvertisementRequest::clear_public_key() {
public_key_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& AdvertisementRequest::public_key() const {
// @@protoc_insertion_point(field_get:location.nearby.mediums.AdvertisementRequest.public_key)
return _internal_public_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void AdvertisementRequest::set_public_key(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:location.nearby.mediums.AdvertisementRequest.public_key)
}
inline std::string* AdvertisementRequest::mutable_public_key() {
std::string* _s = _internal_mutable_public_key();
// @@protoc_insertion_point(field_mutable:location.nearby.mediums.AdvertisementRequest.public_key)
return _s;
}
inline const std::string& AdvertisementRequest::_internal_public_key() const {
return public_key_.Get();
}
inline void AdvertisementRequest::_internal_set_public_key(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* AdvertisementRequest::_internal_mutable_public_key() {
_has_bits_[0] |= 0x00000004u;
return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* AdvertisementRequest::release_public_key() {
// @@protoc_insertion_point(field_release:location.nearby.mediums.AdvertisementRequest.public_key)
if (!_internal_has_public_key()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void AdvertisementRequest::set_allocated_public_key(std::string* public_key) {
if (public_key != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (public_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
public_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.AdvertisementRequest.public_key)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace mediums
} // namespace nearby
} // namespace location
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fmediums_2fnfc_5fframes_2eproto
proto/mediums/web_rtc_signaling_frames.pb.cc
+2192
View File
File diff suppressed because it is too large Load Diff
proto/mediums/web_rtc_signaling_frames.pb.h
+2477
View File
File diff suppressed because it is too large Load Diff
proto/sharing_enums.pb.cc
+1875
View File
File diff suppressed because it is too large Load Diff
proto/sharing_enums.pb.h
+739
View File
@@ -0,0 +1,739 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: proto/sharing_enums.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fsharing_5fenums_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fsharing_5fenums_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_proto_2fsharing_5fenums_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2fsharing_5fenums_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
PROTOBUF_NAMESPACE_OPEN
PROTOBUF_NAMESPACE_CLOSE
namespace location {
namespace nearby {
namespace proto {
namespace sharing {
enum EventType : int {
UNKNOWN_EVENT_TYPE = 0,
ACCEPT_AGREEMENTS = 1,
ENABLE_NEARBY_SHARING = 2,
SET_VISIBILITY = 3,
DESCRIBE_ATTACHMENTS = 4,
SCAN_FOR_SHARE_TARGETS_START = 5,
SCAN_FOR_SHARE_TARGETS_END = 6,
ADVERTISE_DEVICE_PRESENCE_START = 7,
ADVERTISE_DEVICE_PRESENCE_END = 8,
SEND_FAST_INITIALIZATION = 9,
RECEIVE_FAST_INITIALIZATION = 10,
DISCOVER_SHARE_TARGET = 11,
SEND_INTRODUCTION = 12,
RECEIVE_INTRODUCTION = 13,
RESPOND_TO_INTRODUCTION = 14,
SEND_ATTACHMENTS_START = 15,
SEND_ATTACHMENTS_END = 16,
RECEIVE_ATTACHMENTS_START = 17,
RECEIVE_ATTACHMENTS_END = 18,
CANCEL_SENDING_ATTACHMENTS = 19,
CANCEL_RECEIVING_ATTACHMENTS = 20,
OPEN_RECEIVED_ATTACHMENTS = 21,
LAUNCH_SETUP_ACTIVITY PROTOBUF_DEPRECATED_ENUM = 22,
ADD_CONTACT = 23,
REMOVE_CONTACT = 24,
FAST_SHARE_SERVER_RESPONSE = 25,
SEND_START = 26,
ACCEPT_FAST_INITIALIZATION = 27,
SET_DATA_USAGE = 28,
DISMISS_FAST_INITIALIZATION = 29,
CANCEL_CONNECTION = 30,
LAUNCH_ACTIVITY = 31,
DISMISS_PRIVACY_NOTIFICATION = 32,
TAP_PRIVACY_NOTIFICATION = 33,
TAP_HELP = 34,
TAP_FEEDBACK = 35,
ADD_QUICK_SETTINGS_TILE = 36,
REMOVE_QUICK_SETTINGS_TILE = 37,
LAUNCH_PHONE_CONSENT = 38,
TAP_QUICK_SETTINGS_TILE = 39,
INSTALL_APK = 40,
VERIFY_APK = 41,
LAUNCH_CONSENT = 42,
PROCESS_RECEIVED_ATTACHMENTS_END = 43,
TOGGLE_SHOW_NOTIFICATION = 44,
SET_DEVICE_NAME = 45,
DECLINE_AGREEMENTS = 46,
REQUEST_SETTING_PERMISSIONS = 47,
ESTABLISH_CONNECTION = 48,
DEVICE_SETTINGS = 49
};
bool EventType_IsValid(int value);
constexpr EventType EventType_MIN = UNKNOWN_EVENT_TYPE;
constexpr EventType EventType_MAX = DEVICE_SETTINGS;
constexpr int EventType_ARRAYSIZE = EventType_MAX + 1;
const std::string& EventType_Name(EventType value);
template<typename T>
inline const std::string& EventType_Name(T enum_t_value) {
static_assert(::std::is_same<T, EventType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function EventType_Name.");
return EventType_Name(static_cast<EventType>(enum_t_value));
}
bool EventType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventType* value);
enum EventCategory : int {
UNKNOWN_EVENT_CATEGORY = 0,
SENDING_EVENT = 1,
RECEIVING_EVENT = 2,
SETTINGS_EVENT = 3
};
bool EventCategory_IsValid(int value);
constexpr EventCategory EventCategory_MIN = UNKNOWN_EVENT_CATEGORY;
constexpr EventCategory EventCategory_MAX = SETTINGS_EVENT;
constexpr int EventCategory_ARRAYSIZE = EventCategory_MAX + 1;
const std::string& EventCategory_Name(EventCategory value);
template<typename T>
inline const std::string& EventCategory_Name(T enum_t_value) {
static_assert(::std::is_same<T, EventCategory>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function EventCategory_Name.");
return EventCategory_Name(static_cast<EventCategory>(enum_t_value));
}
bool EventCategory_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EventCategory* value);
enum NearbySharingStatus : int {
UNKNOWN_NEARBY_SHARING_STATUS = 0,
ON = 1,
OFF = 2
};
bool NearbySharingStatus_IsValid(int value);
constexpr NearbySharingStatus NearbySharingStatus_MIN = UNKNOWN_NEARBY_SHARING_STATUS;
constexpr NearbySharingStatus NearbySharingStatus_MAX = OFF;
constexpr int NearbySharingStatus_ARRAYSIZE = NearbySharingStatus_MAX + 1;
const std::string& NearbySharingStatus_Name(NearbySharingStatus value);
template<typename T>
inline const std::string& NearbySharingStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, NearbySharingStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function NearbySharingStatus_Name.");
return NearbySharingStatus_Name(static_cast<NearbySharingStatus>(enum_t_value));
}
bool NearbySharingStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NearbySharingStatus* value);
enum Visibility : int {
UNKNOWN_VISIBILITY = 0,
CONTACTS_ONLY = 1,
EVERYONE = 2,
SELECTED_CONTACTS_ONLY = 3,
HIDDEN = 4,
SELF_SHARE = 5
};
bool Visibility_IsValid(int value);
constexpr Visibility Visibility_MIN = UNKNOWN_VISIBILITY;
constexpr Visibility Visibility_MAX = SELF_SHARE;
constexpr int Visibility_ARRAYSIZE = Visibility_MAX + 1;
const std::string& Visibility_Name(Visibility value);
template<typename T>
inline const std::string& Visibility_Name(T enum_t_value) {
static_assert(::std::is_same<T, Visibility>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function Visibility_Name.");
return Visibility_Name(static_cast<Visibility>(enum_t_value));
}
bool Visibility_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Visibility* value);
enum DataUsage : int {
UNKNOWN_DATA_USAGE = 0,
ONLINE = 1,
WIFI_ONLY = 2,
OFFLINE = 3
};
bool DataUsage_IsValid(int value);
constexpr DataUsage DataUsage_MIN = UNKNOWN_DATA_USAGE;
constexpr DataUsage DataUsage_MAX = OFFLINE;
constexpr int DataUsage_ARRAYSIZE = DataUsage_MAX + 1;
const std::string& DataUsage_Name(DataUsage value);
template<typename T>
inline const std::string& DataUsage_Name(T enum_t_value) {
static_assert(::std::is_same<T, DataUsage>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DataUsage_Name.");
return DataUsage_Name(static_cast<DataUsage>(enum_t_value));
}
bool DataUsage_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DataUsage* value);
enum EstablishConnectionStatus : int {
CONNECTION_STATUS_UNKNOWN = 0,
CONNECTION_STATUS_SUCCESS = 1,
CONNECTION_STATUS_FAILURE = 2,
CONNECTION_STATUS_CANCELLATION = 3
};
bool EstablishConnectionStatus_IsValid(int value);
constexpr EstablishConnectionStatus EstablishConnectionStatus_MIN = CONNECTION_STATUS_UNKNOWN;
constexpr EstablishConnectionStatus EstablishConnectionStatus_MAX = CONNECTION_STATUS_CANCELLATION;
constexpr int EstablishConnectionStatus_ARRAYSIZE = EstablishConnectionStatus_MAX + 1;
const std::string& EstablishConnectionStatus_Name(EstablishConnectionStatus value);
template<typename T>
inline const std::string& EstablishConnectionStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, EstablishConnectionStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function EstablishConnectionStatus_Name.");
return EstablishConnectionStatus_Name(static_cast<EstablishConnectionStatus>(enum_t_value));
}
bool EstablishConnectionStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, EstablishConnectionStatus* value);
enum AttachmentTransmissionStatus : int {
UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS = 0,
COMPLETE_ATTACHMENT_TRANSMISSION_STATUS = 1,
CANCELED_ATTACHMENT_TRANSMISSION_STATUS = 2,
FAILED_ATTACHMENT_TRANSMISSION_STATUS = 3,
REJECTED_ATTACHMENT = 4,
TIMED_OUT_ATTACHMENT = 5,
AWAITING_REMOTE_ACCEPTANCE_FAILED_ATTACHMENT PROTOBUF_DEPRECATED_ENUM = 6,
NOT_ENOUGH_SPACE_ATTACHMENT = 7,
FAILED_NO_TRANSFER_UPDATE_CALLBACK = 8,
MEDIA_UNAVAILABLE_ATTACHMENT = 9,
UNSUPPORTED_ATTACHMENT_TYPE_ATTACHMENT = 10,
NO_ATTACHMENT_FOUND = 11,
FAILED_NO_SHARE_TARGET_ENDPOINT = 12,
FAILED_PAIRED_KEYHANDSHAKE = 13,
FAILED_NULL_CONNECTION = 14,
FAILED_NO_PAYLOAD = 15,
FAILED_WRITE_INTRODUCTION = 16,
FAILED_UNKNOWN_REMOTE_RESPONSE = 17
};
bool AttachmentTransmissionStatus_IsValid(int value);
constexpr AttachmentTransmissionStatus AttachmentTransmissionStatus_MIN = UNKNOWN_ATTACHMENT_TRANSMISSION_STATUS;
constexpr AttachmentTransmissionStatus AttachmentTransmissionStatus_MAX = FAILED_UNKNOWN_REMOTE_RESPONSE;
constexpr int AttachmentTransmissionStatus_ARRAYSIZE = AttachmentTransmissionStatus_MAX + 1;
const std::string& AttachmentTransmissionStatus_Name(AttachmentTransmissionStatus value);
template<typename T>
inline const std::string& AttachmentTransmissionStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, AttachmentTransmissionStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function AttachmentTransmissionStatus_Name.");
return AttachmentTransmissionStatus_Name(static_cast<AttachmentTransmissionStatus>(enum_t_value));
}
bool AttachmentTransmissionStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AttachmentTransmissionStatus* value);
enum ProcessReceivedAttachmentsStatus : int {
PROCESSING_STATUS_UNKNOWN = 0,
PROCESSING_STATUS_COMPLETE_PROCESSING_ATTACHMENTS = 1,
PROCESSING_STATUS_FAILED_MOVING_FILES = 2,
PROCESSING_STATUS_FAILED_RECEIVING_APK = 3,
PROCESSING_STATUS_FAILED_RECEIVING_TEXT = 4,
PROCESSING_STATUS_FAILED_RECEIVING_WIFI_CREDENTIALS = 5
};
bool ProcessReceivedAttachmentsStatus_IsValid(int value);
constexpr ProcessReceivedAttachmentsStatus ProcessReceivedAttachmentsStatus_MIN = PROCESSING_STATUS_UNKNOWN;
constexpr ProcessReceivedAttachmentsStatus ProcessReceivedAttachmentsStatus_MAX = PROCESSING_STATUS_FAILED_RECEIVING_WIFI_CREDENTIALS;
constexpr int ProcessReceivedAttachmentsStatus_ARRAYSIZE = ProcessReceivedAttachmentsStatus_MAX + 1;
const std::string& ProcessReceivedAttachmentsStatus_Name(ProcessReceivedAttachmentsStatus value);
template<typename T>
inline const std::string& ProcessReceivedAttachmentsStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, ProcessReceivedAttachmentsStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ProcessReceivedAttachmentsStatus_Name.");
return ProcessReceivedAttachmentsStatus_Name(static_cast<ProcessReceivedAttachmentsStatus>(enum_t_value));
}
bool ProcessReceivedAttachmentsStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProcessReceivedAttachmentsStatus* value);
enum SessionStatus : int {
UNKNOWN_SESSION_STATUS = 0,
SUCCEEDED_SESSION_STATUS = 1,
FAILED_SESSION_STATUS = 2
};
bool SessionStatus_IsValid(int value);
constexpr SessionStatus SessionStatus_MIN = UNKNOWN_SESSION_STATUS;
constexpr SessionStatus SessionStatus_MAX = FAILED_SESSION_STATUS;
constexpr int SessionStatus_ARRAYSIZE = SessionStatus_MAX + 1;
const std::string& SessionStatus_Name(SessionStatus value);
template<typename T>
inline const std::string& SessionStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, SessionStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function SessionStatus_Name.");
return SessionStatus_Name(static_cast<SessionStatus>(enum_t_value));
}
bool SessionStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SessionStatus* value);
enum ResponseToIntroduction : int {
UNKNOWN_RESPONSE_TO_INTRODUCTION = 0,
ACCEPT_INTRODUCTION = 1,
REJECT_INTRODUCTION = 2,
FAIL_INTRODUCTION = 3
};
bool ResponseToIntroduction_IsValid(int value);
constexpr ResponseToIntroduction ResponseToIntroduction_MIN = UNKNOWN_RESPONSE_TO_INTRODUCTION;
constexpr ResponseToIntroduction ResponseToIntroduction_MAX = FAIL_INTRODUCTION;
constexpr int ResponseToIntroduction_ARRAYSIZE = ResponseToIntroduction_MAX + 1;
const std::string& ResponseToIntroduction_Name(ResponseToIntroduction value);
template<typename T>
inline const std::string& ResponseToIntroduction_Name(T enum_t_value) {
static_assert(::std::is_same<T, ResponseToIntroduction>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ResponseToIntroduction_Name.");
return ResponseToIntroduction_Name(static_cast<ResponseToIntroduction>(enum_t_value));
}
bool ResponseToIntroduction_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ResponseToIntroduction* value);
enum DeviceType : int {
UNKNOWN_DEVICE_TYPE = 0,
PHONE = 1,
TABLET = 2,
LAPTOP = 3
};
bool DeviceType_IsValid(int value);
constexpr DeviceType DeviceType_MIN = UNKNOWN_DEVICE_TYPE;
constexpr DeviceType DeviceType_MAX = LAPTOP;
constexpr int DeviceType_ARRAYSIZE = DeviceType_MAX + 1;
const std::string& DeviceType_Name(DeviceType value);
template<typename T>
inline const std::string& DeviceType_Name(T enum_t_value) {
static_assert(::std::is_same<T, DeviceType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DeviceType_Name.");
return DeviceType_Name(static_cast<DeviceType>(enum_t_value));
}
bool DeviceType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceType* value);
enum OSType : int {
UNKNOWN_OS_TYPE = 0,
ANDROID = 1,
CHROME_OS = 2,
IOS = 3
};
bool OSType_IsValid(int value);
constexpr OSType OSType_MIN = UNKNOWN_OS_TYPE;
constexpr OSType OSType_MAX = IOS;
constexpr int OSType_ARRAYSIZE = OSType_MAX + 1;
const std::string& OSType_Name(OSType value);
template<typename T>
inline const std::string& OSType_Name(T enum_t_value) {
static_assert(::std::is_same<T, OSType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function OSType_Name.");
return OSType_Name(static_cast<OSType>(enum_t_value));
}
bool OSType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OSType* value);
enum DeviceRelationship : int {
UNKNOWN_DEVICE_RELATIONSHIP = 0,
IS_SELF = 1,
IS_CONTACT = 2,
IS_STRANGER = 3
};
bool DeviceRelationship_IsValid(int value);
constexpr DeviceRelationship DeviceRelationship_MIN = UNKNOWN_DEVICE_RELATIONSHIP;
constexpr DeviceRelationship DeviceRelationship_MAX = IS_STRANGER;
constexpr int DeviceRelationship_ARRAYSIZE = DeviceRelationship_MAX + 1;
const std::string& DeviceRelationship_Name(DeviceRelationship value);
template<typename T>
inline const std::string& DeviceRelationship_Name(T enum_t_value) {
static_assert(::std::is_same<T, DeviceRelationship>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function DeviceRelationship_Name.");
return DeviceRelationship_Name(static_cast<DeviceRelationship>(enum_t_value));
}
bool DeviceRelationship_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceRelationship* value);
enum LogSource : int {
UNSPECIFIED_SOURCE = 0,
LAB_DEVICES = 1,
INTERNAL_DEVICES = 2,
BETA_TESTER_DEVICES = 3,
OEM_DEVICES = 4,
DEBUG_DEVICES = 5
};
bool LogSource_IsValid(int value);
constexpr LogSource LogSource_MIN = UNSPECIFIED_SOURCE;
constexpr LogSource LogSource_MAX = DEBUG_DEVICES;
constexpr int LogSource_ARRAYSIZE = LogSource_MAX + 1;
const std::string& LogSource_Name(LogSource value);
template<typename T>
inline const std::string& LogSource_Name(T enum_t_value) {
static_assert(::std::is_same<T, LogSource>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function LogSource_Name.");
return LogSource_Name(static_cast<LogSource>(enum_t_value));
}
bool LogSource_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LogSource* value);
enum ServerActionName : int {
UNKNOWN_SERVER_ACTION = 0,
UPLOAD_CERTIFICATES = 1,
DOWNLOAD_CERTIFICATES = 2,
CHECK_REACHABILITY = 3,
UPLOAD_CONTACTS = 4,
UPDATE_DEVICE_NAME = 5,
UPLOAD_SENDER_CERTIFICATES = 6,
DOWNLOAD_SENDER_CERTIFICATES = 7
};
bool ServerActionName_IsValid(int value);
constexpr ServerActionName ServerActionName_MIN = UNKNOWN_SERVER_ACTION;
constexpr ServerActionName ServerActionName_MAX = DOWNLOAD_SENDER_CERTIFICATES;
constexpr int ServerActionName_ARRAYSIZE = ServerActionName_MAX + 1;
const std::string& ServerActionName_Name(ServerActionName value);
template<typename T>
inline const std::string& ServerActionName_Name(T enum_t_value) {
static_assert(::std::is_same<T, ServerActionName>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ServerActionName_Name.");
return ServerActionName_Name(static_cast<ServerActionName>(enum_t_value));
}
bool ServerActionName_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ServerActionName* value);
enum ServerResponseState : int {
UNKNOWN_SERVER_RESPONSE_STATE = 0,
SERVER_RESPONSE_SUCCESS = 1,
SERVER_RESPONSE_UNKNOWN_FAILURE = 2,
SERVER_RESPONSE_STATUS_OTHER_FAILURE = 3,
SERVER_RESPONSE_STATUS_DEADLINE_EXCEEDED = 4,
SERVER_RESPONSE_STATUS_PERMISSION_DENIED = 5,
SERVER_RESPONSE_STATUS_UNAVAILABLE = 6,
SERVER_RESPONSE_STATUS_UNAUTHENTICATED = 7,
SERVER_RESPONSE_STATUS_INVALID_ARGUMENT = 9,
SERVER_RESPONSE_GOOGLE_AUTH_FAILURE = 8
};
bool ServerResponseState_IsValid(int value);
constexpr ServerResponseState ServerResponseState_MIN = UNKNOWN_SERVER_RESPONSE_STATE;
constexpr ServerResponseState ServerResponseState_MAX = SERVER_RESPONSE_STATUS_INVALID_ARGUMENT;
constexpr int ServerResponseState_ARRAYSIZE = ServerResponseState_MAX + 1;
const std::string& ServerResponseState_Name(ServerResponseState value);
template<typename T>
inline const std::string& ServerResponseState_Name(T enum_t_value) {
static_assert(::std::is_same<T, ServerResponseState>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ServerResponseState_Name.");
return ServerResponseState_Name(static_cast<ServerResponseState>(enum_t_value));
}
bool ServerResponseState_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ServerResponseState* value);
enum ScanType : int {
UNKNOWN_SCAN_TYPE = 0,
FOREGROUND_SCAN = 1,
FOREGROUND_RETRY_SCAN = 2,
DIRECT_SHARE_SCAN = 3
};
bool ScanType_IsValid(int value);
constexpr ScanType ScanType_MIN = UNKNOWN_SCAN_TYPE;
constexpr ScanType ScanType_MAX = DIRECT_SHARE_SCAN;
constexpr int ScanType_ARRAYSIZE = ScanType_MAX + 1;
const std::string& ScanType_Name(ScanType value);
template<typename T>
inline const std::string& ScanType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ScanType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ScanType_Name.");
return ScanType_Name(static_cast<ScanType>(enum_t_value));
}
bool ScanType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ScanType* value);
enum ActivityName : int {
UNKNOWN_ACTIVITY = 0,
SHARE_SHEET_ACTIVITY = 1,
SETTINGS_ACTIVITY = 2,
RECEIVE_SURFACE_ACTIVITY = 3,
SETUP_ACTIVITY = 4,
DEVICE_VISIBILITY_ACTIVITY = 5,
CONSENTS_ACTIVITY = 6,
SET_DEVICE_NAME_DIALOG = 7,
SET_DATA_USAGE_DIALOG = 8
};
bool ActivityName_IsValid(int value);
constexpr ActivityName ActivityName_MIN = UNKNOWN_ACTIVITY;
constexpr ActivityName ActivityName_MAX = SET_DATA_USAGE_DIALOG;
constexpr int ActivityName_ARRAYSIZE = ActivityName_MAX + 1;
const std::string& ActivityName_Name(ActivityName value);
template<typename T>
inline const std::string& ActivityName_Name(T enum_t_value) {
static_assert(::std::is_same<T, ActivityName>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ActivityName_Name.");
return ActivityName_Name(static_cast<ActivityName>(enum_t_value));
}
bool ActivityName_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ActivityName* value);
enum ConsentType : int {
CONSENT_TYPE_UNKNOWN = 0,
CONSENT_TYPE_C11N = 1,
CONSENT_TYPE_DEVICE_CONTACT = 2
};
bool ConsentType_IsValid(int value);
constexpr ConsentType ConsentType_MIN = CONSENT_TYPE_UNKNOWN;
constexpr ConsentType ConsentType_MAX = CONSENT_TYPE_DEVICE_CONTACT;
constexpr int ConsentType_ARRAYSIZE = ConsentType_MAX + 1;
const std::string& ConsentType_Name(ConsentType value);
template<typename T>
inline const std::string& ConsentType_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConsentType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConsentType_Name.");
return ConsentType_Name(static_cast<ConsentType>(enum_t_value));
}
bool ConsentType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConsentType* value);
enum ConsentAcceptanceStatus : int {
CONSENT_UNKNOWN_ACCEPT_STATUS = 0,
CONSENT_ACCEPTED = 1,
CONSENT_DECLINED = 2,
CONSENT_UNABLE_TO_ENABLE = 3
};
bool ConsentAcceptanceStatus_IsValid(int value);
constexpr ConsentAcceptanceStatus ConsentAcceptanceStatus_MIN = CONSENT_UNKNOWN_ACCEPT_STATUS;
constexpr ConsentAcceptanceStatus ConsentAcceptanceStatus_MAX = CONSENT_UNABLE_TO_ENABLE;
constexpr int ConsentAcceptanceStatus_ARRAYSIZE = ConsentAcceptanceStatus_MAX + 1;
const std::string& ConsentAcceptanceStatus_Name(ConsentAcceptanceStatus value);
template<typename T>
inline const std::string& ConsentAcceptanceStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, ConsentAcceptanceStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ConsentAcceptanceStatus_Name.");
return ConsentAcceptanceStatus_Name(static_cast<ConsentAcceptanceStatus>(enum_t_value));
}
bool ConsentAcceptanceStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConsentAcceptanceStatus* value);
enum ApkSource : int {
UNKNOWN_APK_SOURCE = 0,
APK_FROM_SD_CARD = 1,
INSTALLED_APP = 2
};
bool ApkSource_IsValid(int value);
constexpr ApkSource ApkSource_MIN = UNKNOWN_APK_SOURCE;
constexpr ApkSource ApkSource_MAX = INSTALLED_APP;
constexpr int ApkSource_ARRAYSIZE = ApkSource_MAX + 1;
const std::string& ApkSource_Name(ApkSource value);
template<typename T>
inline const std::string& ApkSource_Name(T enum_t_value) {
static_assert(::std::is_same<T, ApkSource>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ApkSource_Name.");
return ApkSource_Name(static_cast<ApkSource>(enum_t_value));
}
bool ApkSource_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ApkSource* value);
enum InstallAPKStatus : int {
UNKNOWN_INSTALL_APK_STATUS = 0,
FAIL_INSTALLATION = 1,
SUCCESS_INSTALLATION = 2
};
bool InstallAPKStatus_IsValid(int value);
constexpr InstallAPKStatus InstallAPKStatus_MIN = UNKNOWN_INSTALL_APK_STATUS;
constexpr InstallAPKStatus InstallAPKStatus_MAX = SUCCESS_INSTALLATION;
constexpr int InstallAPKStatus_ARRAYSIZE = InstallAPKStatus_MAX + 1;
const std::string& InstallAPKStatus_Name(InstallAPKStatus value);
template<typename T>
inline const std::string& InstallAPKStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, InstallAPKStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function InstallAPKStatus_Name.");
return InstallAPKStatus_Name(static_cast<InstallAPKStatus>(enum_t_value));
}
bool InstallAPKStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InstallAPKStatus* value);
enum VerifyAPKStatus : int {
UNKNOWN_VERIFY_APK_STATUS = 0,
NOT_INSTALLABLE = 1,
INSTALLABLE = 2,
ALREADY_INSTALLED = 3
};
bool VerifyAPKStatus_IsValid(int value);
constexpr VerifyAPKStatus VerifyAPKStatus_MIN = UNKNOWN_VERIFY_APK_STATUS;
constexpr VerifyAPKStatus VerifyAPKStatus_MAX = ALREADY_INSTALLED;
constexpr int VerifyAPKStatus_ARRAYSIZE = VerifyAPKStatus_MAX + 1;
const std::string& VerifyAPKStatus_Name(VerifyAPKStatus value);
template<typename T>
inline const std::string& VerifyAPKStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, VerifyAPKStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function VerifyAPKStatus_Name.");
return VerifyAPKStatus_Name(static_cast<VerifyAPKStatus>(enum_t_value));
}
bool VerifyAPKStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VerifyAPKStatus* value);
enum ShowNotificationStatus : int {
UNKNOWN_SHOW_NOTIFICATION_STATUS = 0,
SHOW = 1,
NOT_SHOW = 2
};
bool ShowNotificationStatus_IsValid(int value);
constexpr ShowNotificationStatus ShowNotificationStatus_MIN = UNKNOWN_SHOW_NOTIFICATION_STATUS;
constexpr ShowNotificationStatus ShowNotificationStatus_MAX = NOT_SHOW;
constexpr int ShowNotificationStatus_ARRAYSIZE = ShowNotificationStatus_MAX + 1;
const std::string& ShowNotificationStatus_Name(ShowNotificationStatus value);
template<typename T>
inline const std::string& ShowNotificationStatus_Name(T enum_t_value) {
static_assert(::std::is_same<T, ShowNotificationStatus>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function ShowNotificationStatus_Name.");
return ShowNotificationStatus_Name(static_cast<ShowNotificationStatus>(enum_t_value));
}
bool ShowNotificationStatus_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ShowNotificationStatus* value);
enum PermissionRequestResult : int {
PERMISSION_UNKNOWN_REQUEST_RESULT = 0,
PERMISSION_GRANTED = 1,
PERMISSION_REJECTED = 2,
PERMISSION_UNABLE_TO_GRANT = 3
};
bool PermissionRequestResult_IsValid(int value);
constexpr PermissionRequestResult PermissionRequestResult_MIN = PERMISSION_UNKNOWN_REQUEST_RESULT;
constexpr PermissionRequestResult PermissionRequestResult_MAX = PERMISSION_UNABLE_TO_GRANT;
constexpr int PermissionRequestResult_ARRAYSIZE = PermissionRequestResult_MAX + 1;
const std::string& PermissionRequestResult_Name(PermissionRequestResult value);
template<typename T>
inline const std::string& PermissionRequestResult_Name(T enum_t_value) {
static_assert(::std::is_same<T, PermissionRequestResult>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PermissionRequestResult_Name.");
return PermissionRequestResult_Name(static_cast<PermissionRequestResult>(enum_t_value));
}
bool PermissionRequestResult_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PermissionRequestResult* value);
enum PermissionRequestType : int {
PERMISSION_UNKNOWN_TYPE = 0,
PERMISSION_AIRPLANE_MODE_OFF = 1,
PERMISSION_WIFI = 2,
PERMISSION_BLUETOOTH = 3,
PERMISSION_LOCATION = 4
};
bool PermissionRequestType_IsValid(int value);
constexpr PermissionRequestType PermissionRequestType_MIN = PERMISSION_UNKNOWN_TYPE;
constexpr PermissionRequestType PermissionRequestType_MAX = PERMISSION_LOCATION;
constexpr int PermissionRequestType_ARRAYSIZE = PermissionRequestType_MAX + 1;
const std::string& PermissionRequestType_Name(PermissionRequestType value);
template<typename T>
inline const std::string& PermissionRequestType_Name(T enum_t_value) {
static_assert(::std::is_same<T, PermissionRequestType>::value ||
::std::is_integral<T>::value,
"Incorrect type passed to function PermissionRequestType_Name.");
return PermissionRequestType_Name(static_cast<PermissionRequestType>(enum_t_value));
}
bool PermissionRequestType_Parse(
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PermissionRequestType* value);
// ===================================================================
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// @@protoc_insertion_point(namespace_scope)
} // namespace sharing
} // namespace proto
} // namespace nearby
} // namespace location
PROTOBUF_NAMESPACE_OPEN
template <> struct is_proto_enum< ::location::nearby::proto::sharing::EventType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::EventCategory> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::NearbySharingStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::Visibility> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::DataUsage> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::EstablishConnectionStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::AttachmentTransmissionStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ProcessReceivedAttachmentsStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::SessionStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ResponseToIntroduction> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::DeviceType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::OSType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::DeviceRelationship> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::LogSource> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ServerActionName> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ServerResponseState> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ScanType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ActivityName> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ConsentType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ConsentAcceptanceStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ApkSource> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::InstallAPKStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::VerifyAPKStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::ShowNotificationStatus> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::PermissionRequestResult> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::proto::sharing::PermissionRequestType> : ::std::true_type {};
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fsharing_5fenums_2eproto
third_party/google-toolbox-for-mac/google-toolbox-for-mac
Vendored Submodule
+1
Submodule third_party/google-toolbox-for-mac/google-toolbox-for-mac added at 3394150480
third_party/google-toolbox-for-mac/include/GTMDefines.h
Vendored Symlink
+1
View File
@@ -0,0 +1 @@
../google-toolbox-for-mac/GTMDefines.h
third_party/google-toolbox-for-mac/include/GoogleToolboxForMac/GTMLogger.h
Vendored Symlink
+1
View File
@@ -0,0 +1 @@
../../google-toolbox-for-mac/Foundation/GTMLogger.h
third_party/securemessage/compiled_proto/proto/securemessage.pb.cc
Vendored
+2773
View File
File diff suppressed because it is too large Load Diff
third_party/securemessage/compiled_proto/proto/securemessage.pb.h
Vendored
+3069
View File
File diff suppressed because it is too large Load Diff
third_party/securemessage/include/securemessage
Vendored Symlink
+1
View File
@@ -0,0 +1 @@
../securemessage/cpp/include/securemessage
third_party/securemessage/securemessage
Vendored Submodule
+1
Submodule third_party/securemessage/securemessage added at 69a02984d4
third_party/smhasher/include/src
Vendored Symlink
+1
View File
@@ -0,0 +1 @@
../../smhasher/smhasher/src
third_party/smhasher → third_party/smhasher/smhasher
Vendored
View File
third_party/ukey2/compiled_proto/proto/device_to_device_messages.pb.cc
Vendored
+1586
View File
File diff suppressed because it is too large Load Diff
third_party/ukey2/compiled_proto/proto/device_to_device_messages.pb.h
Vendored
+1776
View File
File diff suppressed because it is too large Load Diff
third_party/ukey2/compiled_proto/proto/passwordless_auth_payloads.pb.cc
Vendored
+328
View File
@@ -0,0 +1,328 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: proto/passwordless_auth_payloads.proto
#include "proto/passwordless_auth_payloads.pb.h"
#include <algorithm>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
PROTOBUF_PRAGMA_INIT_SEG
namespace securegcm {
constexpr IdentityAssertion::IdentityAssertion(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: browser_data_hash_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, counter_(int64_t{0})
, user_approval_(0){}
struct IdentityAssertionDefaultTypeInternal {
constexpr IdentityAssertionDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~IdentityAssertionDefaultTypeInternal() {}
union {
IdentityAssertion _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT IdentityAssertionDefaultTypeInternal _IdentityAssertion_default_instance_;
} // namespace securegcm
namespace securegcm {
// ===================================================================
class IdentityAssertion::_Internal {
public:
using HasBits = decltype(std::declval<IdentityAssertion>()._has_bits_);
static void set_has_browser_data_hash(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_counter(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
static void set_has_user_approval(HasBits* has_bits) {
(*has_bits)[0] |= 4u;
}
};
IdentityAssertion::IdentityAssertion(::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:securegcm.IdentityAssertion)
}
IdentityAssertion::IdentityAssertion(const IdentityAssertion& from)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
browser_data_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
browser_data_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_browser_data_hash()) {
browser_data_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_browser_data_hash(),
GetArenaForAllocation());
}
::memcpy(&counter_, &from.counter_,
static_cast<size_t>(reinterpret_cast<char*>(&user_approval_) -
reinterpret_cast<char*>(&counter_)) + sizeof(user_approval_));
// @@protoc_insertion_point(copy_constructor:securegcm.IdentityAssertion)
}
inline void IdentityAssertion::SharedCtor() {
browser_data_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
browser_data_hash_.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*>(&counter_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&user_approval_) -
reinterpret_cast<char*>(&counter_)) + sizeof(user_approval_));
}
IdentityAssertion::~IdentityAssertion() {
// @@protoc_insertion_point(destructor:securegcm.IdentityAssertion)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<std::string>();
}
inline void IdentityAssertion::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
browser_data_hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
void IdentityAssertion::ArenaDtor(void* object) {
IdentityAssertion* _this = reinterpret_cast< IdentityAssertion* >(object);
(void)_this;
}
void IdentityAssertion::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void IdentityAssertion::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void IdentityAssertion::Clear() {
// @@protoc_insertion_point(message_clear_start:securegcm.IdentityAssertion)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000001u) {
browser_data_hash_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000006u) {
::memset(&counter_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&user_approval_) -
reinterpret_cast<char*>(&counter_)) + sizeof(user_approval_));
}
_has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
}
const char* IdentityAssertion::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional bytes browser_data_hash = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
auto str = _internal_mutable_browser_data_hash();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional int64 counter = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
_Internal::set_has_counter(&has_bits);
counter_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional int32 user_approval = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
_Internal::set_has_user_approval(&has_bits);
user_approval_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<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* IdentityAssertion::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:securegcm.IdentityAssertion)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
// optional bytes browser_data_hash = 1;
if (cached_has_bits & 0x00000001u) {
target = stream->WriteBytesMaybeAliased(
1, this->_internal_browser_data_hash(), target);
}
// optional int64 counter = 2;
if (cached_has_bits & 0x00000002u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_counter(), target);
}
// optional int32 user_approval = 3;
if (cached_has_bits & 0x00000004u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_user_approval(), 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:securegcm.IdentityAssertion)
return target;
}
size_t IdentityAssertion::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:securegcm.IdentityAssertion)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000007u) {
// optional bytes browser_data_hash = 1;
if (cached_has_bits & 0x00000001u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
this->_internal_browser_data_hash());
}
// optional int64 counter = 2;
if (cached_has_bits & 0x00000002u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_counter());
}
// optional int32 user_approval = 3;
if (cached_has_bits & 0x00000004u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_user_approval());
}
}
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 IdentityAssertion::CheckTypeAndMergeFrom(
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const IdentityAssertion*>(
&from));
}
void IdentityAssertion::MergeFrom(const IdentityAssertion& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:securegcm.IdentityAssertion)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x00000007u) {
if (cached_has_bits & 0x00000001u) {
_internal_set_browser_data_hash(from._internal_browser_data_hash());
}
if (cached_has_bits & 0x00000002u) {
counter_ = from.counter_;
}
if (cached_has_bits & 0x00000004u) {
user_approval_ = from.user_approval_;
}
_has_bits_[0] |= cached_has_bits;
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
void IdentityAssertion::CopyFrom(const IdentityAssertion& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:securegcm.IdentityAssertion)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool IdentityAssertion::IsInitialized() const {
return true;
}
void IdentityAssertion::InternalSwap(IdentityAssertion* other) {
using std::swap;
auto* lhs_arena = GetArenaForAllocation();
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&browser_data_hash_, lhs_arena,
&other->browser_data_hash_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(IdentityAssertion, user_approval_)
+ sizeof(IdentityAssertion::user_approval_)
- PROTOBUF_FIELD_OFFSET(IdentityAssertion, counter_)>(
reinterpret_cast<char*>(&counter_),
reinterpret_cast<char*>(&other->counter_));
}
std::string IdentityAssertion::GetTypeName() const {
return "securegcm.IdentityAssertion";
}
// @@protoc_insertion_point(namespace_scope)
} // namespace securegcm
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::securegcm::IdentityAssertion* Arena::CreateMaybeMessage< ::securegcm::IdentityAssertion >(Arena* arena) {
return Arena::CreateMessageInternal< ::securegcm::IdentityAssertion >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
third_party/ukey2/compiled_proto/proto/passwordless_auth_payloads.pb.h
Vendored
+387
View File
@@ -0,0 +1,387 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: proto/passwordless_auth_payloads.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fpasswordless_5fauth_5fpayloads_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fpasswordless_5fauth_5fpayloads_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_proto_2fpasswordless_5fauth_5fpayloads_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2fpasswordless_5fauth_5fpayloads_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
namespace securegcm {
class IdentityAssertion;
struct IdentityAssertionDefaultTypeInternal;
extern IdentityAssertionDefaultTypeInternal _IdentityAssertion_default_instance_;
} // namespace securegcm
PROTOBUF_NAMESPACE_OPEN
template<> ::securegcm::IdentityAssertion* Arena::CreateMaybeMessage<::securegcm::IdentityAssertion>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace securegcm {
// ===================================================================
class IdentityAssertion final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.IdentityAssertion) */ {
public:
inline IdentityAssertion() : IdentityAssertion(nullptr) {}
~IdentityAssertion() override;
explicit constexpr IdentityAssertion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
IdentityAssertion(const IdentityAssertion& from);
IdentityAssertion(IdentityAssertion&& from) noexcept
: IdentityAssertion() {
*this = ::std::move(from);
}
inline IdentityAssertion& operator=(const IdentityAssertion& from) {
CopyFrom(from);
return *this;
}
inline IdentityAssertion& operator=(IdentityAssertion&& 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 IdentityAssertion& default_instance() {
return *internal_default_instance();
}
static inline const IdentityAssertion* internal_default_instance() {
return reinterpret_cast<const IdentityAssertion*>(
&_IdentityAssertion_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(IdentityAssertion& a, IdentityAssertion& b) {
a.Swap(&b);
}
inline void Swap(IdentityAssertion* 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(IdentityAssertion* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
IdentityAssertion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<IdentityAssertion>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const IdentityAssertion& from);
void MergeFrom(const IdentityAssertion& 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(IdentityAssertion* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "securegcm.IdentityAssertion";
}
protected:
explicit IdentityAssertion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kBrowserDataHashFieldNumber = 1,
kCounterFieldNumber = 2,
kUserApprovalFieldNumber = 3,
};
// optional bytes browser_data_hash = 1;
bool has_browser_data_hash() const;
private:
bool _internal_has_browser_data_hash() const;
public:
void clear_browser_data_hash();
const std::string& browser_data_hash() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_browser_data_hash(ArgT0&& arg0, ArgT... args);
std::string* mutable_browser_data_hash();
PROTOBUF_NODISCARD std::string* release_browser_data_hash();
void set_allocated_browser_data_hash(std::string* browser_data_hash);
private:
const std::string& _internal_browser_data_hash() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_browser_data_hash(const std::string& value);
std::string* _internal_mutable_browser_data_hash();
public:
// optional int64 counter = 2;
bool has_counter() const;
private:
bool _internal_has_counter() const;
public:
void clear_counter();
int64_t counter() const;
void set_counter(int64_t value);
private:
int64_t _internal_counter() const;
void _internal_set_counter(int64_t value);
public:
// optional int32 user_approval = 3;
bool has_user_approval() const;
private:
bool _internal_has_user_approval() const;
public:
void clear_user_approval();
int32_t user_approval() const;
void set_user_approval(int32_t value);
private:
int32_t _internal_user_approval() const;
void _internal_set_user_approval(int32_t value);
public:
// @@protoc_insertion_point(class_scope:securegcm.IdentityAssertion)
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::internal::ArenaStringPtr browser_data_hash_;
int64_t counter_;
int32_t user_approval_;
friend struct ::TableStruct_proto_2fpasswordless_5fauth_5fpayloads_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// IdentityAssertion
// optional bytes browser_data_hash = 1;
inline bool IdentityAssertion::_internal_has_browser_data_hash() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool IdentityAssertion::has_browser_data_hash() const {
return _internal_has_browser_data_hash();
}
inline void IdentityAssertion::clear_browser_data_hash() {
browser_data_hash_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& IdentityAssertion::browser_data_hash() const {
// @@protoc_insertion_point(field_get:securegcm.IdentityAssertion.browser_data_hash)
return _internal_browser_data_hash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IdentityAssertion::set_browser_data_hash(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
browser_data_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:securegcm.IdentityAssertion.browser_data_hash)
}
inline std::string* IdentityAssertion::mutable_browser_data_hash() {
std::string* _s = _internal_mutable_browser_data_hash();
// @@protoc_insertion_point(field_mutable:securegcm.IdentityAssertion.browser_data_hash)
return _s;
}
inline const std::string& IdentityAssertion::_internal_browser_data_hash() const {
return browser_data_hash_.Get();
}
inline void IdentityAssertion::_internal_set_browser_data_hash(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
browser_data_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* IdentityAssertion::_internal_mutable_browser_data_hash() {
_has_bits_[0] |= 0x00000001u;
return browser_data_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* IdentityAssertion::release_browser_data_hash() {
// @@protoc_insertion_point(field_release:securegcm.IdentityAssertion.browser_data_hash)
if (!_internal_has_browser_data_hash()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = browser_data_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (browser_data_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
browser_data_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void IdentityAssertion::set_allocated_browser_data_hash(std::string* browser_data_hash) {
if (browser_data_hash != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
browser_data_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), browser_data_hash,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (browser_data_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
browser_data_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:securegcm.IdentityAssertion.browser_data_hash)
}
// optional int64 counter = 2;
inline bool IdentityAssertion::_internal_has_counter() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool IdentityAssertion::has_counter() const {
return _internal_has_counter();
}
inline void IdentityAssertion::clear_counter() {
counter_ = int64_t{0};
_has_bits_[0] &= ~0x00000002u;
}
inline int64_t IdentityAssertion::_internal_counter() const {
return counter_;
}
inline int64_t IdentityAssertion::counter() const {
// @@protoc_insertion_point(field_get:securegcm.IdentityAssertion.counter)
return _internal_counter();
}
inline void IdentityAssertion::_internal_set_counter(int64_t value) {
_has_bits_[0] |= 0x00000002u;
counter_ = value;
}
inline void IdentityAssertion::set_counter(int64_t value) {
_internal_set_counter(value);
// @@protoc_insertion_point(field_set:securegcm.IdentityAssertion.counter)
}
// optional int32 user_approval = 3;
inline bool IdentityAssertion::_internal_has_user_approval() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool IdentityAssertion::has_user_approval() const {
return _internal_has_user_approval();
}
inline void IdentityAssertion::clear_user_approval() {
user_approval_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t IdentityAssertion::_internal_user_approval() const {
return user_approval_;
}
inline int32_t IdentityAssertion::user_approval() const {
// @@protoc_insertion_point(field_get:securegcm.IdentityAssertion.user_approval)
return _internal_user_approval();
}
inline void IdentityAssertion::_internal_set_user_approval(int32_t value) {
_has_bits_[0] |= 0x00000004u;
user_approval_ = value;
}
inline void IdentityAssertion::set_user_approval(int32_t value) {
_internal_set_user_approval(value);
// @@protoc_insertion_point(field_set:securegcm.IdentityAssertion.user_approval)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// @@protoc_insertion_point(namespace_scope)
} // namespace securegcm
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fpasswordless_5fauth_5fpayloads_2eproto
third_party/ukey2/compiled_proto/proto/proximity_payloads.pb.cc
Vendored
+716
View File
@@ -0,0 +1,716 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: proto/proximity_payloads.proto
#include "proto/proximity_payloads.pb.h"
#include <algorithm>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
PROTOBUF_PRAGMA_INIT_SEG
namespace securegcm {
constexpr CloudToDeviceProximityAuthPairing::CloudToDeviceProximityAuthPairing(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: initiating_device_name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, initiating_device_bt_address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, ephemeral_symmetric_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, additional_metadata_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct CloudToDeviceProximityAuthPairingDefaultTypeInternal {
constexpr CloudToDeviceProximityAuthPairingDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~CloudToDeviceProximityAuthPairingDefaultTypeInternal() {}
union {
CloudToDeviceProximityAuthPairing _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CloudToDeviceProximityAuthPairingDefaultTypeInternal _CloudToDeviceProximityAuthPairing_default_instance_;
constexpr DeviceProximityCallback::DeviceProximityCallback(
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
: callback_bluetooth_address_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
, source_device_type_(0)
, protocol_version_(0){}
struct DeviceProximityCallbackDefaultTypeInternal {
constexpr DeviceProximityCallbackDefaultTypeInternal()
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
~DeviceProximityCallbackDefaultTypeInternal() {}
union {
DeviceProximityCallback _instance;
};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DeviceProximityCallbackDefaultTypeInternal _DeviceProximityCallback_default_instance_;
} // namespace securegcm
namespace securegcm {
// ===================================================================
class CloudToDeviceProximityAuthPairing::_Internal {
public:
using HasBits = decltype(std::declval<CloudToDeviceProximityAuthPairing>()._has_bits_);
static void set_has_initiating_device_name(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_initiating_device_bt_address(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
static void set_has_ephemeral_symmetric_key(HasBits* has_bits) {
(*has_bits)[0] |= 4u;
}
static void set_has_additional_metadata(HasBits* has_bits) {
(*has_bits)[0] |= 8u;
}
};
CloudToDeviceProximityAuthPairing::CloudToDeviceProximityAuthPairing(::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:securegcm.CloudToDeviceProximityAuthPairing)
}
CloudToDeviceProximityAuthPairing::CloudToDeviceProximityAuthPairing(const CloudToDeviceProximityAuthPairing& from)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
initiating_device_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
initiating_device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_initiating_device_name()) {
initiating_device_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_initiating_device_name(),
GetArenaForAllocation());
}
initiating_device_bt_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
initiating_device_bt_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_initiating_device_bt_address()) {
initiating_device_bt_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_initiating_device_bt_address(),
GetArenaForAllocation());
}
ephemeral_symmetric_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
ephemeral_symmetric_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_ephemeral_symmetric_key()) {
ephemeral_symmetric_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_ephemeral_symmetric_key(),
GetArenaForAllocation());
}
additional_metadata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
additional_metadata_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_additional_metadata()) {
additional_metadata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_additional_metadata(),
GetArenaForAllocation());
}
// @@protoc_insertion_point(copy_constructor:securegcm.CloudToDeviceProximityAuthPairing)
}
inline void CloudToDeviceProximityAuthPairing::SharedCtor() {
initiating_device_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
initiating_device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
initiating_device_bt_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
initiating_device_bt_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
ephemeral_symmetric_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
ephemeral_symmetric_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
additional_metadata_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
additional_metadata_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}
CloudToDeviceProximityAuthPairing::~CloudToDeviceProximityAuthPairing() {
// @@protoc_insertion_point(destructor:securegcm.CloudToDeviceProximityAuthPairing)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<std::string>();
}
inline void CloudToDeviceProximityAuthPairing::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
initiating_device_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
initiating_device_bt_address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
ephemeral_symmetric_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
additional_metadata_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
void CloudToDeviceProximityAuthPairing::ArenaDtor(void* object) {
CloudToDeviceProximityAuthPairing* _this = reinterpret_cast< CloudToDeviceProximityAuthPairing* >(object);
(void)_this;
}
void CloudToDeviceProximityAuthPairing::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void CloudToDeviceProximityAuthPairing::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void CloudToDeviceProximityAuthPairing::Clear() {
// @@protoc_insertion_point(message_clear_start:securegcm.CloudToDeviceProximityAuthPairing)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x0000000fu) {
if (cached_has_bits & 0x00000001u) {
initiating_device_name_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000002u) {
initiating_device_bt_address_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000004u) {
ephemeral_symmetric_key_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000008u) {
additional_metadata_.ClearNonDefaultToEmpty();
}
}
_has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
}
const char* CloudToDeviceProximityAuthPairing::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional string initiating_device_name = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
auto str = _internal_mutable_initiating_device_name();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional string initiating_device_bt_address = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
auto str = _internal_mutable_initiating_device_bt_address();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional bytes ephemeral_symmetric_key = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
auto str = _internal_mutable_ephemeral_symmetric_key();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional bytes additional_metadata = 4;
case 4:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
auto str = _internal_mutable_additional_metadata();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<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* CloudToDeviceProximityAuthPairing::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:securegcm.CloudToDeviceProximityAuthPairing)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
// optional string initiating_device_name = 1;
if (cached_has_bits & 0x00000001u) {
target = stream->WriteStringMaybeAliased(
1, this->_internal_initiating_device_name(), target);
}
// optional string initiating_device_bt_address = 2;
if (cached_has_bits & 0x00000002u) {
target = stream->WriteStringMaybeAliased(
2, this->_internal_initiating_device_bt_address(), target);
}
// optional bytes ephemeral_symmetric_key = 3;
if (cached_has_bits & 0x00000004u) {
target = stream->WriteBytesMaybeAliased(
3, this->_internal_ephemeral_symmetric_key(), target);
}
// optional bytes additional_metadata = 4;
if (cached_has_bits & 0x00000008u) {
target = stream->WriteBytesMaybeAliased(
4, this->_internal_additional_metadata(), 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:securegcm.CloudToDeviceProximityAuthPairing)
return target;
}
size_t CloudToDeviceProximityAuthPairing::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:securegcm.CloudToDeviceProximityAuthPairing)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x0000000fu) {
// optional string initiating_device_name = 1;
if (cached_has_bits & 0x00000001u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_initiating_device_name());
}
// optional string initiating_device_bt_address = 2;
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_initiating_device_bt_address());
}
// optional bytes ephemeral_symmetric_key = 3;
if (cached_has_bits & 0x00000004u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
this->_internal_ephemeral_symmetric_key());
}
// optional bytes additional_metadata = 4;
if (cached_has_bits & 0x00000008u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
this->_internal_additional_metadata());
}
}
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 CloudToDeviceProximityAuthPairing::CheckTypeAndMergeFrom(
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const CloudToDeviceProximityAuthPairing*>(
&from));
}
void CloudToDeviceProximityAuthPairing::MergeFrom(const CloudToDeviceProximityAuthPairing& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:securegcm.CloudToDeviceProximityAuthPairing)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x0000000fu) {
if (cached_has_bits & 0x00000001u) {
_internal_set_initiating_device_name(from._internal_initiating_device_name());
}
if (cached_has_bits & 0x00000002u) {
_internal_set_initiating_device_bt_address(from._internal_initiating_device_bt_address());
}
if (cached_has_bits & 0x00000004u) {
_internal_set_ephemeral_symmetric_key(from._internal_ephemeral_symmetric_key());
}
if (cached_has_bits & 0x00000008u) {
_internal_set_additional_metadata(from._internal_additional_metadata());
}
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
void CloudToDeviceProximityAuthPairing::CopyFrom(const CloudToDeviceProximityAuthPairing& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:securegcm.CloudToDeviceProximityAuthPairing)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool CloudToDeviceProximityAuthPairing::IsInitialized() const {
return true;
}
void CloudToDeviceProximityAuthPairing::InternalSwap(CloudToDeviceProximityAuthPairing* other) {
using std::swap;
auto* lhs_arena = GetArenaForAllocation();
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&initiating_device_name_, lhs_arena,
&other->initiating_device_name_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&initiating_device_bt_address_, lhs_arena,
&other->initiating_device_bt_address_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&ephemeral_symmetric_key_, lhs_arena,
&other->ephemeral_symmetric_key_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&additional_metadata_, lhs_arena,
&other->additional_metadata_, rhs_arena
);
}
std::string CloudToDeviceProximityAuthPairing::GetTypeName() const {
return "securegcm.CloudToDeviceProximityAuthPairing";
}
// ===================================================================
class DeviceProximityCallback::_Internal {
public:
using HasBits = decltype(std::declval<DeviceProximityCallback>()._has_bits_);
static void set_has_callback_bluetooth_address(HasBits* has_bits) {
(*has_bits)[0] |= 1u;
}
static void set_has_source_device_type(HasBits* has_bits) {
(*has_bits)[0] |= 2u;
}
static void set_has_protocol_version(HasBits* has_bits) {
(*has_bits)[0] |= 4u;
}
};
DeviceProximityCallback::DeviceProximityCallback(::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:securegcm.DeviceProximityCallback)
}
DeviceProximityCallback::DeviceProximityCallback(const DeviceProximityCallback& from)
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
_has_bits_(from._has_bits_) {
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
callback_bluetooth_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
callback_bluetooth_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (from._internal_has_callback_bluetooth_address()) {
callback_bluetooth_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_callback_bluetooth_address(),
GetArenaForAllocation());
}
::memcpy(&source_device_type_, &from.source_device_type_,
static_cast<size_t>(reinterpret_cast<char*>(&protocol_version_) -
reinterpret_cast<char*>(&source_device_type_)) + sizeof(protocol_version_));
// @@protoc_insertion_point(copy_constructor:securegcm.DeviceProximityCallback)
}
inline void DeviceProximityCallback::SharedCtor() {
callback_bluetooth_address_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
callback_bluetooth_address_.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*>(&source_device_type_) - reinterpret_cast<char*>(this)),
0, static_cast<size_t>(reinterpret_cast<char*>(&protocol_version_) -
reinterpret_cast<char*>(&source_device_type_)) + sizeof(protocol_version_));
}
DeviceProximityCallback::~DeviceProximityCallback() {
// @@protoc_insertion_point(destructor:securegcm.DeviceProximityCallback)
if (GetArenaForAllocation() != nullptr) return;
SharedDtor();
_internal_metadata_.Delete<std::string>();
}
inline void DeviceProximityCallback::SharedDtor() {
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
callback_bluetooth_address_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
void DeviceProximityCallback::ArenaDtor(void* object) {
DeviceProximityCallback* _this = reinterpret_cast< DeviceProximityCallback* >(object);
(void)_this;
}
void DeviceProximityCallback::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DeviceProximityCallback::SetCachedSize(int size) const {
_cached_size_.Set(size);
}
void DeviceProximityCallback::Clear() {
// @@protoc_insertion_point(message_clear_start:securegcm.DeviceProximityCallback)
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000001u) {
callback_bluetooth_address_.ClearNonDefaultToEmpty();
}
if (cached_has_bits & 0x00000006u) {
::memset(&source_device_type_, 0, static_cast<size_t>(
reinterpret_cast<char*>(&protocol_version_) -
reinterpret_cast<char*>(&source_device_type_)) + sizeof(protocol_version_));
}
_has_bits_.Clear();
_internal_metadata_.Clear<std::string>();
}
const char* DeviceProximityCallback::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
switch (tag >> 3) {
// optional string callback_bluetooth_address = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
auto str = _internal_mutable_callback_bluetooth_address();
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
} else
goto handle_unusual;
continue;
// optional .securegcm.DeviceType source_device_type = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
if (PROTOBUF_PREDICT_TRUE(::securegcm::DeviceType_IsValid(val))) {
_internal_set_source_device_type(static_cast<::securegcm::DeviceType>(val));
} else {
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
}
} else
goto handle_unusual;
continue;
// optional int32 protocol_version = 3;
case 3:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
_Internal::set_has_protocol_version(&has_bits);
protocol_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<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* DeviceProximityCallback::_InternalSerialize(
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
// @@protoc_insertion_point(serialize_to_array_start:securegcm.DeviceProximityCallback)
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
// optional string callback_bluetooth_address = 1;
if (cached_has_bits & 0x00000001u) {
target = stream->WriteStringMaybeAliased(
1, this->_internal_callback_bluetooth_address(), target);
}
// optional .securegcm.DeviceType source_device_type = 2;
if (cached_has_bits & 0x00000002u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
2, this->_internal_source_device_type(), target);
}
// optional int32 protocol_version = 3;
if (cached_has_bits & 0x00000004u) {
target = stream->EnsureSpace(target);
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_protocol_version(), 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:securegcm.DeviceProximityCallback)
return target;
}
size_t DeviceProximityCallback::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:securegcm.DeviceProximityCallback)
size_t total_size = 0;
uint32_t cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
cached_has_bits = _has_bits_[0];
if (cached_has_bits & 0x00000007u) {
// optional string callback_bluetooth_address = 1;
if (cached_has_bits & 0x00000001u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
this->_internal_callback_bluetooth_address());
}
// optional .securegcm.DeviceType source_device_type = 2;
if (cached_has_bits & 0x00000002u) {
total_size += 1 +
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_source_device_type());
}
// optional int32 protocol_version = 3;
if (cached_has_bits & 0x00000004u) {
total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_protocol_version());
}
}
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 DeviceProximityCallback::CheckTypeAndMergeFrom(
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const DeviceProximityCallback*>(
&from));
}
void DeviceProximityCallback::MergeFrom(const DeviceProximityCallback& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:securegcm.DeviceProximityCallback)
GOOGLE_DCHECK_NE(&from, this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
cached_has_bits = from._has_bits_[0];
if (cached_has_bits & 0x00000007u) {
if (cached_has_bits & 0x00000001u) {
_internal_set_callback_bluetooth_address(from._internal_callback_bluetooth_address());
}
if (cached_has_bits & 0x00000002u) {
source_device_type_ = from.source_device_type_;
}
if (cached_has_bits & 0x00000004u) {
protocol_version_ = from.protocol_version_;
}
_has_bits_[0] |= cached_has_bits;
}
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}
void DeviceProximityCallback::CopyFrom(const DeviceProximityCallback& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:securegcm.DeviceProximityCallback)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool DeviceProximityCallback::IsInitialized() const {
return true;
}
void DeviceProximityCallback::InternalSwap(DeviceProximityCallback* other) {
using std::swap;
auto* lhs_arena = GetArenaForAllocation();
auto* rhs_arena = other->GetArenaForAllocation();
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
swap(_has_bits_[0], other->_has_bits_[0]);
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
&callback_bluetooth_address_, lhs_arena,
&other->callback_bluetooth_address_, rhs_arena
);
::PROTOBUF_NAMESPACE_ID::internal::memswap<
PROTOBUF_FIELD_OFFSET(DeviceProximityCallback, protocol_version_)
+ sizeof(DeviceProximityCallback::protocol_version_)
- PROTOBUF_FIELD_OFFSET(DeviceProximityCallback, source_device_type_)>(
reinterpret_cast<char*>(&source_device_type_),
reinterpret_cast<char*>(&other->source_device_type_));
}
std::string DeviceProximityCallback::GetTypeName() const {
return "securegcm.DeviceProximityCallback";
}
// @@protoc_insertion_point(namespace_scope)
} // namespace securegcm
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::securegcm::CloudToDeviceProximityAuthPairing* Arena::CreateMaybeMessage< ::securegcm::CloudToDeviceProximityAuthPairing >(Arena* arena) {
return Arena::CreateMessageInternal< ::securegcm::CloudToDeviceProximityAuthPairing >(arena);
}
template<> PROTOBUF_NOINLINE ::securegcm::DeviceProximityCallback* Arena::CreateMaybeMessage< ::securegcm::DeviceProximityCallback >(Arena* arena) {
return Arena::CreateMessageInternal< ::securegcm::DeviceProximityCallback >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
third_party/ukey2/compiled_proto/proto/proximity_payloads.pb.h
Vendored
+882
View File
@@ -0,0 +1,882 @@
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: proto/proximity_payloads.proto
#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fproximity_5fpayloads_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fproximity_5fpayloads_2eproto
#include <limits>
#include <string>
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include "securegcm.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_proto_2fproximity_5fpayloads_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
} // namespace internal
PROTOBUF_NAMESPACE_CLOSE
// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2fproximity_5fpayloads_2eproto {
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
static const uint32_t offsets[];
};
namespace securegcm {
class CloudToDeviceProximityAuthPairing;
struct CloudToDeviceProximityAuthPairingDefaultTypeInternal;
extern CloudToDeviceProximityAuthPairingDefaultTypeInternal _CloudToDeviceProximityAuthPairing_default_instance_;
class DeviceProximityCallback;
struct DeviceProximityCallbackDefaultTypeInternal;
extern DeviceProximityCallbackDefaultTypeInternal _DeviceProximityCallback_default_instance_;
} // namespace securegcm
PROTOBUF_NAMESPACE_OPEN
template<> ::securegcm::CloudToDeviceProximityAuthPairing* Arena::CreateMaybeMessage<::securegcm::CloudToDeviceProximityAuthPairing>(Arena*);
template<> ::securegcm::DeviceProximityCallback* Arena::CreateMaybeMessage<::securegcm::DeviceProximityCallback>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace securegcm {
// ===================================================================
class CloudToDeviceProximityAuthPairing final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.CloudToDeviceProximityAuthPairing) */ {
public:
inline CloudToDeviceProximityAuthPairing() : CloudToDeviceProximityAuthPairing(nullptr) {}
~CloudToDeviceProximityAuthPairing() override;
explicit constexpr CloudToDeviceProximityAuthPairing(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
CloudToDeviceProximityAuthPairing(const CloudToDeviceProximityAuthPairing& from);
CloudToDeviceProximityAuthPairing(CloudToDeviceProximityAuthPairing&& from) noexcept
: CloudToDeviceProximityAuthPairing() {
*this = ::std::move(from);
}
inline CloudToDeviceProximityAuthPairing& operator=(const CloudToDeviceProximityAuthPairing& from) {
CopyFrom(from);
return *this;
}
inline CloudToDeviceProximityAuthPairing& operator=(CloudToDeviceProximityAuthPairing&& 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 CloudToDeviceProximityAuthPairing& default_instance() {
return *internal_default_instance();
}
static inline const CloudToDeviceProximityAuthPairing* internal_default_instance() {
return reinterpret_cast<const CloudToDeviceProximityAuthPairing*>(
&_CloudToDeviceProximityAuthPairing_default_instance_);
}
static constexpr int kIndexInFileMessages =
0;
friend void swap(CloudToDeviceProximityAuthPairing& a, CloudToDeviceProximityAuthPairing& b) {
a.Swap(&b);
}
inline void Swap(CloudToDeviceProximityAuthPairing* 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(CloudToDeviceProximityAuthPairing* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
CloudToDeviceProximityAuthPairing* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<CloudToDeviceProximityAuthPairing>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const CloudToDeviceProximityAuthPairing& from);
void MergeFrom(const CloudToDeviceProximityAuthPairing& 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(CloudToDeviceProximityAuthPairing* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "securegcm.CloudToDeviceProximityAuthPairing";
}
protected:
explicit CloudToDeviceProximityAuthPairing(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kInitiatingDeviceNameFieldNumber = 1,
kInitiatingDeviceBtAddressFieldNumber = 2,
kEphemeralSymmetricKeyFieldNumber = 3,
kAdditionalMetadataFieldNumber = 4,
};
// optional string initiating_device_name = 1;
bool has_initiating_device_name() const;
private:
bool _internal_has_initiating_device_name() const;
public:
void clear_initiating_device_name();
const std::string& initiating_device_name() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_initiating_device_name(ArgT0&& arg0, ArgT... args);
std::string* mutable_initiating_device_name();
PROTOBUF_NODISCARD std::string* release_initiating_device_name();
void set_allocated_initiating_device_name(std::string* initiating_device_name);
private:
const std::string& _internal_initiating_device_name() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_initiating_device_name(const std::string& value);
std::string* _internal_mutable_initiating_device_name();
public:
// optional string initiating_device_bt_address = 2;
bool has_initiating_device_bt_address() const;
private:
bool _internal_has_initiating_device_bt_address() const;
public:
void clear_initiating_device_bt_address();
const std::string& initiating_device_bt_address() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_initiating_device_bt_address(ArgT0&& arg0, ArgT... args);
std::string* mutable_initiating_device_bt_address();
PROTOBUF_NODISCARD std::string* release_initiating_device_bt_address();
void set_allocated_initiating_device_bt_address(std::string* initiating_device_bt_address);
private:
const std::string& _internal_initiating_device_bt_address() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_initiating_device_bt_address(const std::string& value);
std::string* _internal_mutable_initiating_device_bt_address();
public:
// optional bytes ephemeral_symmetric_key = 3;
bool has_ephemeral_symmetric_key() const;
private:
bool _internal_has_ephemeral_symmetric_key() const;
public:
void clear_ephemeral_symmetric_key();
const std::string& ephemeral_symmetric_key() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_ephemeral_symmetric_key(ArgT0&& arg0, ArgT... args);
std::string* mutable_ephemeral_symmetric_key();
PROTOBUF_NODISCARD std::string* release_ephemeral_symmetric_key();
void set_allocated_ephemeral_symmetric_key(std::string* ephemeral_symmetric_key);
private:
const std::string& _internal_ephemeral_symmetric_key() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_ephemeral_symmetric_key(const std::string& value);
std::string* _internal_mutable_ephemeral_symmetric_key();
public:
// optional bytes additional_metadata = 4;
bool has_additional_metadata() const;
private:
bool _internal_has_additional_metadata() const;
public:
void clear_additional_metadata();
const std::string& additional_metadata() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_additional_metadata(ArgT0&& arg0, ArgT... args);
std::string* mutable_additional_metadata();
PROTOBUF_NODISCARD std::string* release_additional_metadata();
void set_allocated_additional_metadata(std::string* additional_metadata);
private:
const std::string& _internal_additional_metadata() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_additional_metadata(const std::string& value);
std::string* _internal_mutable_additional_metadata();
public:
// @@protoc_insertion_point(class_scope:securegcm.CloudToDeviceProximityAuthPairing)
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::internal::ArenaStringPtr initiating_device_name_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr initiating_device_bt_address_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ephemeral_symmetric_key_;
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr additional_metadata_;
friend struct ::TableStruct_proto_2fproximity_5fpayloads_2eproto;
};
// -------------------------------------------------------------------
class DeviceProximityCallback final :
public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:securegcm.DeviceProximityCallback) */ {
public:
inline DeviceProximityCallback() : DeviceProximityCallback(nullptr) {}
~DeviceProximityCallback() override;
explicit constexpr DeviceProximityCallback(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
DeviceProximityCallback(const DeviceProximityCallback& from);
DeviceProximityCallback(DeviceProximityCallback&& from) noexcept
: DeviceProximityCallback() {
*this = ::std::move(from);
}
inline DeviceProximityCallback& operator=(const DeviceProximityCallback& from) {
CopyFrom(from);
return *this;
}
inline DeviceProximityCallback& operator=(DeviceProximityCallback&& 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 DeviceProximityCallback& default_instance() {
return *internal_default_instance();
}
static inline const DeviceProximityCallback* internal_default_instance() {
return reinterpret_cast<const DeviceProximityCallback*>(
&_DeviceProximityCallback_default_instance_);
}
static constexpr int kIndexInFileMessages =
1;
friend void swap(DeviceProximityCallback& a, DeviceProximityCallback& b) {
a.Swap(&b);
}
inline void Swap(DeviceProximityCallback* 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(DeviceProximityCallback* other) {
if (other == this) return;
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
InternalSwap(other);
}
// implements Message ----------------------------------------------
DeviceProximityCallback* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
return CreateMaybeMessage<DeviceProximityCallback>(arena);
}
void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
void CopyFrom(const DeviceProximityCallback& from);
void MergeFrom(const DeviceProximityCallback& 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(DeviceProximityCallback* other);
private:
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
return "securegcm.DeviceProximityCallback";
}
protected:
explicit DeviceProximityCallback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
bool is_message_owned = false);
private:
static void ArenaDtor(void* object);
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
public:
std::string GetTypeName() const final;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
enum : int {
kCallbackBluetoothAddressFieldNumber = 1,
kSourceDeviceTypeFieldNumber = 2,
kProtocolVersionFieldNumber = 3,
};
// optional string callback_bluetooth_address = 1;
bool has_callback_bluetooth_address() const;
private:
bool _internal_has_callback_bluetooth_address() const;
public:
void clear_callback_bluetooth_address();
const std::string& callback_bluetooth_address() const;
template <typename ArgT0 = const std::string&, typename... ArgT>
void set_callback_bluetooth_address(ArgT0&& arg0, ArgT... args);
std::string* mutable_callback_bluetooth_address();
PROTOBUF_NODISCARD std::string* release_callback_bluetooth_address();
void set_allocated_callback_bluetooth_address(std::string* callback_bluetooth_address);
private:
const std::string& _internal_callback_bluetooth_address() const;
inline PROTOBUF_ALWAYS_INLINE void _internal_set_callback_bluetooth_address(const std::string& value);
std::string* _internal_mutable_callback_bluetooth_address();
public:
// optional .securegcm.DeviceType source_device_type = 2;
bool has_source_device_type() const;
private:
bool _internal_has_source_device_type() const;
public:
void clear_source_device_type();
::securegcm::DeviceType source_device_type() const;
void set_source_device_type(::securegcm::DeviceType value);
private:
::securegcm::DeviceType _internal_source_device_type() const;
void _internal_set_source_device_type(::securegcm::DeviceType value);
public:
// optional int32 protocol_version = 3;
bool has_protocol_version() const;
private:
bool _internal_has_protocol_version() const;
public:
void clear_protocol_version();
int32_t protocol_version() const;
void set_protocol_version(int32_t value);
private:
int32_t _internal_protocol_version() const;
void _internal_set_protocol_version(int32_t value);
public:
// @@protoc_insertion_point(class_scope:securegcm.DeviceProximityCallback)
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::internal::ArenaStringPtr callback_bluetooth_address_;
int source_device_type_;
int32_t protocol_version_;
friend struct ::TableStruct_proto_2fproximity_5fpayloads_2eproto;
};
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
// CloudToDeviceProximityAuthPairing
// optional string initiating_device_name = 1;
inline bool CloudToDeviceProximityAuthPairing::_internal_has_initiating_device_name() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool CloudToDeviceProximityAuthPairing::has_initiating_device_name() const {
return _internal_has_initiating_device_name();
}
inline void CloudToDeviceProximityAuthPairing::clear_initiating_device_name() {
initiating_device_name_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CloudToDeviceProximityAuthPairing::initiating_device_name() const {
// @@protoc_insertion_point(field_get:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_name)
return _internal_initiating_device_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CloudToDeviceProximityAuthPairing::set_initiating_device_name(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
initiating_device_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_name)
}
inline std::string* CloudToDeviceProximityAuthPairing::mutable_initiating_device_name() {
std::string* _s = _internal_mutable_initiating_device_name();
// @@protoc_insertion_point(field_mutable:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_name)
return _s;
}
inline const std::string& CloudToDeviceProximityAuthPairing::_internal_initiating_device_name() const {
return initiating_device_name_.Get();
}
inline void CloudToDeviceProximityAuthPairing::_internal_set_initiating_device_name(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
initiating_device_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CloudToDeviceProximityAuthPairing::_internal_mutable_initiating_device_name() {
_has_bits_[0] |= 0x00000001u;
return initiating_device_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CloudToDeviceProximityAuthPairing::release_initiating_device_name() {
// @@protoc_insertion_point(field_release:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_name)
if (!_internal_has_initiating_device_name()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = initiating_device_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (initiating_device_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
initiating_device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void CloudToDeviceProximityAuthPairing::set_allocated_initiating_device_name(std::string* initiating_device_name) {
if (initiating_device_name != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
initiating_device_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), initiating_device_name,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (initiating_device_name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
initiating_device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_name)
}
// optional string initiating_device_bt_address = 2;
inline bool CloudToDeviceProximityAuthPairing::_internal_has_initiating_device_bt_address() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool CloudToDeviceProximityAuthPairing::has_initiating_device_bt_address() const {
return _internal_has_initiating_device_bt_address();
}
inline void CloudToDeviceProximityAuthPairing::clear_initiating_device_bt_address() {
initiating_device_bt_address_.ClearToEmpty();
_has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CloudToDeviceProximityAuthPairing::initiating_device_bt_address() const {
// @@protoc_insertion_point(field_get:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_bt_address)
return _internal_initiating_device_bt_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CloudToDeviceProximityAuthPairing::set_initiating_device_bt_address(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000002u;
initiating_device_bt_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_bt_address)
}
inline std::string* CloudToDeviceProximityAuthPairing::mutable_initiating_device_bt_address() {
std::string* _s = _internal_mutable_initiating_device_bt_address();
// @@protoc_insertion_point(field_mutable:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_bt_address)
return _s;
}
inline const std::string& CloudToDeviceProximityAuthPairing::_internal_initiating_device_bt_address() const {
return initiating_device_bt_address_.Get();
}
inline void CloudToDeviceProximityAuthPairing::_internal_set_initiating_device_bt_address(const std::string& value) {
_has_bits_[0] |= 0x00000002u;
initiating_device_bt_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CloudToDeviceProximityAuthPairing::_internal_mutable_initiating_device_bt_address() {
_has_bits_[0] |= 0x00000002u;
return initiating_device_bt_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CloudToDeviceProximityAuthPairing::release_initiating_device_bt_address() {
// @@protoc_insertion_point(field_release:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_bt_address)
if (!_internal_has_initiating_device_bt_address()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000002u;
auto* p = initiating_device_bt_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (initiating_device_bt_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
initiating_device_bt_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void CloudToDeviceProximityAuthPairing::set_allocated_initiating_device_bt_address(std::string* initiating_device_bt_address) {
if (initiating_device_bt_address != nullptr) {
_has_bits_[0] |= 0x00000002u;
} else {
_has_bits_[0] &= ~0x00000002u;
}
initiating_device_bt_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), initiating_device_bt_address,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (initiating_device_bt_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
initiating_device_bt_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:securegcm.CloudToDeviceProximityAuthPairing.initiating_device_bt_address)
}
// optional bytes ephemeral_symmetric_key = 3;
inline bool CloudToDeviceProximityAuthPairing::_internal_has_ephemeral_symmetric_key() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool CloudToDeviceProximityAuthPairing::has_ephemeral_symmetric_key() const {
return _internal_has_ephemeral_symmetric_key();
}
inline void CloudToDeviceProximityAuthPairing::clear_ephemeral_symmetric_key() {
ephemeral_symmetric_key_.ClearToEmpty();
_has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CloudToDeviceProximityAuthPairing::ephemeral_symmetric_key() const {
// @@protoc_insertion_point(field_get:securegcm.CloudToDeviceProximityAuthPairing.ephemeral_symmetric_key)
return _internal_ephemeral_symmetric_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CloudToDeviceProximityAuthPairing::set_ephemeral_symmetric_key(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000004u;
ephemeral_symmetric_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:securegcm.CloudToDeviceProximityAuthPairing.ephemeral_symmetric_key)
}
inline std::string* CloudToDeviceProximityAuthPairing::mutable_ephemeral_symmetric_key() {
std::string* _s = _internal_mutable_ephemeral_symmetric_key();
// @@protoc_insertion_point(field_mutable:securegcm.CloudToDeviceProximityAuthPairing.ephemeral_symmetric_key)
return _s;
}
inline const std::string& CloudToDeviceProximityAuthPairing::_internal_ephemeral_symmetric_key() const {
return ephemeral_symmetric_key_.Get();
}
inline void CloudToDeviceProximityAuthPairing::_internal_set_ephemeral_symmetric_key(const std::string& value) {
_has_bits_[0] |= 0x00000004u;
ephemeral_symmetric_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CloudToDeviceProximityAuthPairing::_internal_mutable_ephemeral_symmetric_key() {
_has_bits_[0] |= 0x00000004u;
return ephemeral_symmetric_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CloudToDeviceProximityAuthPairing::release_ephemeral_symmetric_key() {
// @@protoc_insertion_point(field_release:securegcm.CloudToDeviceProximityAuthPairing.ephemeral_symmetric_key)
if (!_internal_has_ephemeral_symmetric_key()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000004u;
auto* p = ephemeral_symmetric_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (ephemeral_symmetric_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
ephemeral_symmetric_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void CloudToDeviceProximityAuthPairing::set_allocated_ephemeral_symmetric_key(std::string* ephemeral_symmetric_key) {
if (ephemeral_symmetric_key != nullptr) {
_has_bits_[0] |= 0x00000004u;
} else {
_has_bits_[0] &= ~0x00000004u;
}
ephemeral_symmetric_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ephemeral_symmetric_key,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (ephemeral_symmetric_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
ephemeral_symmetric_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:securegcm.CloudToDeviceProximityAuthPairing.ephemeral_symmetric_key)
}
// optional bytes additional_metadata = 4;
inline bool CloudToDeviceProximityAuthPairing::_internal_has_additional_metadata() const {
bool value = (_has_bits_[0] & 0x00000008u) != 0;
return value;
}
inline bool CloudToDeviceProximityAuthPairing::has_additional_metadata() const {
return _internal_has_additional_metadata();
}
inline void CloudToDeviceProximityAuthPairing::clear_additional_metadata() {
additional_metadata_.ClearToEmpty();
_has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CloudToDeviceProximityAuthPairing::additional_metadata() const {
// @@protoc_insertion_point(field_get:securegcm.CloudToDeviceProximityAuthPairing.additional_metadata)
return _internal_additional_metadata();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CloudToDeviceProximityAuthPairing::set_additional_metadata(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000008u;
additional_metadata_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:securegcm.CloudToDeviceProximityAuthPairing.additional_metadata)
}
inline std::string* CloudToDeviceProximityAuthPairing::mutable_additional_metadata() {
std::string* _s = _internal_mutable_additional_metadata();
// @@protoc_insertion_point(field_mutable:securegcm.CloudToDeviceProximityAuthPairing.additional_metadata)
return _s;
}
inline const std::string& CloudToDeviceProximityAuthPairing::_internal_additional_metadata() const {
return additional_metadata_.Get();
}
inline void CloudToDeviceProximityAuthPairing::_internal_set_additional_metadata(const std::string& value) {
_has_bits_[0] |= 0x00000008u;
additional_metadata_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CloudToDeviceProximityAuthPairing::_internal_mutable_additional_metadata() {
_has_bits_[0] |= 0x00000008u;
return additional_metadata_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CloudToDeviceProximityAuthPairing::release_additional_metadata() {
// @@protoc_insertion_point(field_release:securegcm.CloudToDeviceProximityAuthPairing.additional_metadata)
if (!_internal_has_additional_metadata()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000008u;
auto* p = additional_metadata_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (additional_metadata_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
additional_metadata_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void CloudToDeviceProximityAuthPairing::set_allocated_additional_metadata(std::string* additional_metadata) {
if (additional_metadata != nullptr) {
_has_bits_[0] |= 0x00000008u;
} else {
_has_bits_[0] &= ~0x00000008u;
}
additional_metadata_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), additional_metadata,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (additional_metadata_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
additional_metadata_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:securegcm.CloudToDeviceProximityAuthPairing.additional_metadata)
}
// -------------------------------------------------------------------
// DeviceProximityCallback
// optional string callback_bluetooth_address = 1;
inline bool DeviceProximityCallback::_internal_has_callback_bluetooth_address() const {
bool value = (_has_bits_[0] & 0x00000001u) != 0;
return value;
}
inline bool DeviceProximityCallback::has_callback_bluetooth_address() const {
return _internal_has_callback_bluetooth_address();
}
inline void DeviceProximityCallback::clear_callback_bluetooth_address() {
callback_bluetooth_address_.ClearToEmpty();
_has_bits_[0] &= ~0x00000001u;
}
inline const std::string& DeviceProximityCallback::callback_bluetooth_address() const {
// @@protoc_insertion_point(field_get:securegcm.DeviceProximityCallback.callback_bluetooth_address)
return _internal_callback_bluetooth_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void DeviceProximityCallback::set_callback_bluetooth_address(ArgT0&& arg0, ArgT... args) {
_has_bits_[0] |= 0x00000001u;
callback_bluetooth_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
// @@protoc_insertion_point(field_set:securegcm.DeviceProximityCallback.callback_bluetooth_address)
}
inline std::string* DeviceProximityCallback::mutable_callback_bluetooth_address() {
std::string* _s = _internal_mutable_callback_bluetooth_address();
// @@protoc_insertion_point(field_mutable:securegcm.DeviceProximityCallback.callback_bluetooth_address)
return _s;
}
inline const std::string& DeviceProximityCallback::_internal_callback_bluetooth_address() const {
return callback_bluetooth_address_.Get();
}
inline void DeviceProximityCallback::_internal_set_callback_bluetooth_address(const std::string& value) {
_has_bits_[0] |= 0x00000001u;
callback_bluetooth_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* DeviceProximityCallback::_internal_mutable_callback_bluetooth_address() {
_has_bits_[0] |= 0x00000001u;
return callback_bluetooth_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* DeviceProximityCallback::release_callback_bluetooth_address() {
// @@protoc_insertion_point(field_release:securegcm.DeviceProximityCallback.callback_bluetooth_address)
if (!_internal_has_callback_bluetooth_address()) {
return nullptr;
}
_has_bits_[0] &= ~0x00000001u;
auto* p = callback_bluetooth_address_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (callback_bluetooth_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
callback_bluetooth_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
return p;
}
inline void DeviceProximityCallback::set_allocated_callback_bluetooth_address(std::string* callback_bluetooth_address) {
if (callback_bluetooth_address != nullptr) {
_has_bits_[0] |= 0x00000001u;
} else {
_has_bits_[0] &= ~0x00000001u;
}
callback_bluetooth_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), callback_bluetooth_address,
GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
if (callback_bluetooth_address_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
callback_bluetooth_address_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
}
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
// @@protoc_insertion_point(field_set_allocated:securegcm.DeviceProximityCallback.callback_bluetooth_address)
}
// optional .securegcm.DeviceType source_device_type = 2;
inline bool DeviceProximityCallback::_internal_has_source_device_type() const {
bool value = (_has_bits_[0] & 0x00000002u) != 0;
return value;
}
inline bool DeviceProximityCallback::has_source_device_type() const {
return _internal_has_source_device_type();
}
inline void DeviceProximityCallback::clear_source_device_type() {
source_device_type_ = 0;
_has_bits_[0] &= ~0x00000002u;
}
inline ::securegcm::DeviceType DeviceProximityCallback::_internal_source_device_type() const {
return static_cast< ::securegcm::DeviceType >(source_device_type_);
}
inline ::securegcm::DeviceType DeviceProximityCallback::source_device_type() const {
// @@protoc_insertion_point(field_get:securegcm.DeviceProximityCallback.source_device_type)
return _internal_source_device_type();
}
inline void DeviceProximityCallback::_internal_set_source_device_type(::securegcm::DeviceType value) {
assert(::securegcm::DeviceType_IsValid(value));
_has_bits_[0] |= 0x00000002u;
source_device_type_ = value;
}
inline void DeviceProximityCallback::set_source_device_type(::securegcm::DeviceType value) {
_internal_set_source_device_type(value);
// @@protoc_insertion_point(field_set:securegcm.DeviceProximityCallback.source_device_type)
}
// optional int32 protocol_version = 3;
inline bool DeviceProximityCallback::_internal_has_protocol_version() const {
bool value = (_has_bits_[0] & 0x00000004u) != 0;
return value;
}
inline bool DeviceProximityCallback::has_protocol_version() const {
return _internal_has_protocol_version();
}
inline void DeviceProximityCallback::clear_protocol_version() {
protocol_version_ = 0;
_has_bits_[0] &= ~0x00000004u;
}
inline int32_t DeviceProximityCallback::_internal_protocol_version() const {
return protocol_version_;
}
inline int32_t DeviceProximityCallback::protocol_version() const {
// @@protoc_insertion_point(field_get:securegcm.DeviceProximityCallback.protocol_version)
return _internal_protocol_version();
}
inline void DeviceProximityCallback::_internal_set_protocol_version(int32_t value) {
_has_bits_[0] |= 0x00000004u;
protocol_version_ = value;
}
inline void DeviceProximityCallback::set_protocol_version(int32_t value) {
_internal_set_protocol_version(value);
// @@protoc_insertion_point(field_set:securegcm.DeviceProximityCallback.protocol_version)
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// -------------------------------------------------------------------
// @@protoc_insertion_point(namespace_scope)
} // namespace securegcm
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fproximity_5fpayloads_2eproto
third_party/ukey2/compiled_proto/proto/securegcm.pb.cc
Vendored
+3021
View File
File diff suppressed because it is too large Load Diff
third_party/ukey2/compiled_proto/proto/securegcm.pb.h
Vendored
+3756
View File
File diff suppressed because it is too large Load Diff
third_party/ukey2/compiled_proto/proto/securemessage.pb.cc
Vendored
+2773
View File
File diff suppressed because it is too large Load Diff
third_party/ukey2/compiled_proto/proto/securemessage.pb.h
Vendored
+3069
View File
File diff suppressed because it is too large Load Diff
third_party/ukey2/compiled_proto/proto/ukey.pb.cc
Vendored
+1990
View File
File diff suppressed because it is too large Load Diff
third_party/ukey2/compiled_proto/proto/ukey.pb.h
Vendored
+2085
View File
File diff suppressed because it is too large Load Diff
third_party/ukey2/include/proto/ukey.pb.h
Vendored
+2085
View File
File diff suppressed because it is too large Load Diff
third_party/ukey2/include/securegcm
Vendored Symlink
+1
View File
@@ -0,0 +1 @@
../ukey2/src/main/cpp/include/securegcm
third_party/ukey2 → third_party/ukey2/ukey2
Vendored
View File