mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-14 22:56:12 -04:00
Compile protos with v33.3
This commit is contained in:
Nick Bourdakos
@@ -1,85 +1,181 @@
|
||||
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
||||
// NO CHECKED-IN PROTOBUF GENCODE
|
||||
// source: proto/errorcode/error_code_enums.proto
|
||||
// Protobuf C++ Version: 6.33.3
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
|
||||
#define GOOGLE_PROTOBUF_INCLUDED_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
|
||||
#ifndef proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto_2epb_2eh
|
||||
#define proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto_2epb_2eh
|
||||
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
#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.
|
||||
#include "google/protobuf/runtime_version.h"
|
||||
#if PROTOBUF_VERSION != 6033003
|
||||
#error "Protobuf C++ gencode is built with an incompatible version of"
|
||||
#error "Protobuf C++ headers/runtime. See"
|
||||
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
|
||||
#endif
|
||||
#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION
|
||||
#error This file was generated by an older version of protoc which is
|
||||
#error incompatible with your Protocol Buffer headers. Please
|
||||
#error regenerate this file with a newer version of protoc.
|
||||
#endif
|
||||
|
||||
#include <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>
|
||||
#include "google/protobuf/io/coded_stream.h"
|
||||
#include "google/protobuf/arena.h"
|
||||
#include "google/protobuf/arenastring.h"
|
||||
#include "google/protobuf/generated_message_tctable_decl.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>
|
||||
|
||||
// Must be included last.
|
||||
#include "google/protobuf/port_def.inc"
|
||||
|
||||
#define PROTOBUF_INTERNAL_EXPORT_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
namespace internal {
|
||||
class AnyMetadata;
|
||||
template <typename T>
|
||||
::absl::string_view GetAnyMessageName();
|
||||
} // namespace internal
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
// 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[];
|
||||
static const ::uint32_t offsets[];
|
||||
};
|
||||
PROTOBUF_NAMESPACE_OPEN
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
namespace location {
|
||||
namespace nearby {
|
||||
namespace errorcode {
|
||||
namespace proto {
|
||||
enum AcceptConnectionError : int;
|
||||
extern const uint32_t AcceptConnectionError_internal_data_[];
|
||||
enum CommonError : int;
|
||||
extern const uint32_t CommonError_internal_data_[];
|
||||
enum ConnectError : int;
|
||||
extern const uint32_t ConnectError_internal_data_[];
|
||||
enum Description : int;
|
||||
extern const uint32_t Description_internal_data_[];
|
||||
enum DisconnectError : int;
|
||||
extern const uint32_t DisconnectError_internal_data_[];
|
||||
enum ErrorType : int;
|
||||
extern const uint32_t ErrorType_internal_data_[];
|
||||
enum Event : int;
|
||||
extern const uint32_t Event_internal_data_[];
|
||||
enum ReceivePayloadError : int;
|
||||
extern const uint32_t ReceivePayloadError_internal_data_[];
|
||||
enum RejectConnectionError : int;
|
||||
extern const uint32_t RejectConnectionError_internal_data_[];
|
||||
enum SendPayloadError : int;
|
||||
extern const uint32_t SendPayloadError_internal_data_[];
|
||||
enum StartAdvertisingError : int;
|
||||
extern const uint32_t StartAdvertisingError_internal_data_[];
|
||||
enum StartDiscoveringError : int;
|
||||
extern const uint32_t StartDiscoveringError_internal_data_[];
|
||||
enum StartListeningIncomingConnectionError : int;
|
||||
extern const uint32_t StartListeningIncomingConnectionError_internal_data_[];
|
||||
enum StopAdvertisingError : int;
|
||||
extern const uint32_t StopAdvertisingError_internal_data_[];
|
||||
enum StopDiscoveringError : int;
|
||||
extern const uint32_t StopDiscoveringError_internal_data_[];
|
||||
enum StopListeningIncomingConnectionError : int;
|
||||
extern const uint32_t StopListeningIncomingConnectionError_internal_data_[];
|
||||
enum UpgradeError : int;
|
||||
extern const uint32_t UpgradeError_internal_data_[];
|
||||
} // namespace proto
|
||||
} // namespace errorcode
|
||||
} // namespace nearby
|
||||
} // namespace location
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::AcceptConnectionError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::AcceptConnectionError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::CommonError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::CommonError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::ConnectError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::ConnectError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::Description_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::Description>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::DisconnectError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::DisconnectError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::ErrorType_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::ErrorType>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::Event_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::Event>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::ReceivePayloadError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::ReceivePayloadError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::RejectConnectionError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::RejectConnectionError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::SendPayloadError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::SendPayloadError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::StartAdvertisingError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StartAdvertisingError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::StartDiscoveringError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StartDiscoveringError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::StartListeningIncomingConnectionError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StartListeningIncomingConnectionError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::StopAdvertisingError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StopAdvertisingError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::StopDiscoveringError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StopDiscoveringError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::StopListeningIncomingConnectionError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::StopListeningIncomingConnectionError>;
|
||||
template <>
|
||||
internal::EnumTraitsT<::location::nearby::errorcode::proto::UpgradeError_internal_data_>
|
||||
internal::EnumTraitsImpl::value<::location::nearby::errorcode::proto::UpgradeError>;
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
namespace location {
|
||||
namespace nearby {
|
||||
namespace errorcode {
|
||||
namespace proto {
|
||||
enum ErrorType : int {
|
||||
UNKNOWN_TYPE = 0,
|
||||
DEVELOPING = 1,
|
||||
DEVICE = 2,
|
||||
SYSTEM = 3,
|
||||
NETWORK = 4,
|
||||
OTHERS = 5
|
||||
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) {
|
||||
extern const uint32_t ErrorType_internal_data_[];
|
||||
inline constexpr ErrorType ErrorType_MIN =
|
||||
static_cast<ErrorType>(0);
|
||||
inline constexpr ErrorType ErrorType_MAX =
|
||||
static_cast<ErrorType>(5);
|
||||
inline bool ErrorType_IsValid(int value) {
|
||||
return 0 <= value && value <= 5;
|
||||
}
|
||||
inline constexpr int ErrorType_ARRAYSIZE = 5 + 1;
|
||||
const ::std::string& ErrorType_Name(ErrorType value);
|
||||
template <typename T>
|
||||
const ::std::string& ErrorType_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to ErrorType_Name().");
|
||||
return ErrorType_Name(static_cast<ErrorType>(value));
|
||||
}
|
||||
bool ErrorType_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ErrorType* value);
|
||||
::absl::string_view name, ErrorType* PROTOBUF_NONNULL value);
|
||||
enum Event : int {
|
||||
UNKNOWN_EVENT = 0,
|
||||
START_ADVERTISING = 1,
|
||||
@@ -95,23 +191,28 @@ enum Event : int {
|
||||
SEND_PAYLOAD = 11,
|
||||
CANCEL_PAYLOAD = 12,
|
||||
RECEIVE_PAYLOAD = 13,
|
||||
UPGRADE = 14
|
||||
UPGRADE = 14,
|
||||
};
|
||||
bool Event_IsValid(int value);
|
||||
constexpr Event Event_MIN = UNKNOWN_EVENT;
|
||||
constexpr Event Event_MAX = UPGRADE;
|
||||
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) {
|
||||
extern const uint32_t Event_internal_data_[];
|
||||
inline constexpr Event Event_MIN =
|
||||
static_cast<Event>(0);
|
||||
inline constexpr Event Event_MAX =
|
||||
static_cast<Event>(14);
|
||||
inline bool Event_IsValid(int value) {
|
||||
return 0 <= value && value <= 14;
|
||||
}
|
||||
inline constexpr int Event_ARRAYSIZE = 14 + 1;
|
||||
const ::std::string& Event_Name(Event value);
|
||||
template <typename T>
|
||||
const ::std::string& Event_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to Event_Name().");
|
||||
return Event_Name(static_cast<Event>(value));
|
||||
}
|
||||
bool Event_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Event* value);
|
||||
::absl::string_view name, Event* PROTOBUF_NONNULL value);
|
||||
enum CommonError : int {
|
||||
UNKNOWN_ERROR = 0,
|
||||
INVALID_PARAMETER = 1,
|
||||
@@ -119,23 +220,28 @@ enum CommonError : int {
|
||||
UNEXPECTED_MEDIUM_STATE = 3,
|
||||
OUT_OF_RESOURCE = 4,
|
||||
FLOW_CANCELED = 5,
|
||||
UNEXPECTED_CALL = 6
|
||||
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) {
|
||||
extern const uint32_t CommonError_internal_data_[];
|
||||
inline constexpr CommonError CommonError_MIN =
|
||||
static_cast<CommonError>(0);
|
||||
inline constexpr CommonError CommonError_MAX =
|
||||
static_cast<CommonError>(6);
|
||||
inline bool CommonError_IsValid(int value) {
|
||||
return 0 <= value && value <= 6;
|
||||
}
|
||||
inline constexpr int CommonError_ARRAYSIZE = 6 + 1;
|
||||
const ::std::string& CommonError_Name(CommonError value);
|
||||
template <typename T>
|
||||
const ::std::string& CommonError_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to CommonError_Name().");
|
||||
return CommonError_Name(static_cast<CommonError>(value));
|
||||
}
|
||||
bool CommonError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CommonError* value);
|
||||
::absl::string_view name, CommonError* PROTOBUF_NONNULL value);
|
||||
enum StartAdvertisingError : int {
|
||||
MULTIPLE_FAST_ADVERTISEMENT_NOT_ALLOWED = 31,
|
||||
FAST_ADVERTISEMENT_ALREADY_ADVERTISED = 32,
|
||||
@@ -151,45 +257,55 @@ enum StartAdvertisingError : int {
|
||||
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
|
||||
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) {
|
||||
extern const uint32_t StartAdvertisingError_internal_data_[];
|
||||
inline constexpr StartAdvertisingError StartAdvertisingError_MIN =
|
||||
static_cast<StartAdvertisingError>(31);
|
||||
inline constexpr StartAdvertisingError StartAdvertisingError_MAX =
|
||||
static_cast<StartAdvertisingError>(47);
|
||||
inline bool StartAdvertisingError_IsValid(int value) {
|
||||
return 0 <= value && value <= 47 && ((280785634459648u >> value) & 1) != 0;
|
||||
}
|
||||
inline constexpr int StartAdvertisingError_ARRAYSIZE = 47 + 1;
|
||||
const ::std::string& StartAdvertisingError_Name(StartAdvertisingError value);
|
||||
template <typename T>
|
||||
const ::std::string& StartAdvertisingError_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to StartAdvertisingError_Name().");
|
||||
return StartAdvertisingError_Name(static_cast<StartAdvertisingError>(value));
|
||||
}
|
||||
bool StartAdvertisingError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartAdvertisingError* value);
|
||||
::absl::string_view name, StartAdvertisingError* PROTOBUF_NONNULL 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
|
||||
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) {
|
||||
extern const uint32_t StopAdvertisingError_internal_data_[];
|
||||
inline constexpr StopAdvertisingError StopAdvertisingError_MIN =
|
||||
static_cast<StopAdvertisingError>(31);
|
||||
inline constexpr StopAdvertisingError StopAdvertisingError_MAX =
|
||||
static_cast<StopAdvertisingError>(35);
|
||||
inline bool StopAdvertisingError_IsValid(int value) {
|
||||
return 31 <= value && value <= 35;
|
||||
}
|
||||
inline constexpr int StopAdvertisingError_ARRAYSIZE = 35 + 1;
|
||||
const ::std::string& StopAdvertisingError_Name(StopAdvertisingError value);
|
||||
template <typename T>
|
||||
const ::std::string& StopAdvertisingError_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to StopAdvertisingError_Name().");
|
||||
return StopAdvertisingError_Name(static_cast<StopAdvertisingError>(value));
|
||||
}
|
||||
bool StopAdvertisingError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopAdvertisingError* value);
|
||||
::absl::string_view name, StopAdvertisingError* PROTOBUF_NONNULL value);
|
||||
enum StartDiscoveringError : int {
|
||||
DUPLICATE_DISCOVERING_REQUESTED = 31,
|
||||
START_LEGACY_DISCOVERING_FAILED = 32,
|
||||
@@ -201,44 +317,54 @@ enum StartDiscoveringError : int {
|
||||
L2CAP_FETCH_ADVERTISEMENT_FAILED = 38,
|
||||
NOT_AVAILABLE_TO_FETCH_ADVERTISEMENT = 39,
|
||||
ACQUIRE_WIFI_AWARE_SESSION_FOR_DISCOVERING_FAILED = 40,
|
||||
UNKNOWN_START_DISCOVERING_ERROR = 41
|
||||
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) {
|
||||
extern const uint32_t StartDiscoveringError_internal_data_[];
|
||||
inline constexpr StartDiscoveringError StartDiscoveringError_MIN =
|
||||
static_cast<StartDiscoveringError>(31);
|
||||
inline constexpr StartDiscoveringError StartDiscoveringError_MAX =
|
||||
static_cast<StartDiscoveringError>(41);
|
||||
inline bool StartDiscoveringError_IsValid(int value) {
|
||||
return 31 <= value && value <= 41;
|
||||
}
|
||||
inline constexpr int StartDiscoveringError_ARRAYSIZE = 41 + 1;
|
||||
const ::std::string& StartDiscoveringError_Name(StartDiscoveringError value);
|
||||
template <typename T>
|
||||
const ::std::string& StartDiscoveringError_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to StartDiscoveringError_Name().");
|
||||
return StartDiscoveringError_Name(static_cast<StartDiscoveringError>(value));
|
||||
}
|
||||
bool StartDiscoveringError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartDiscoveringError* value);
|
||||
::absl::string_view name, StartDiscoveringError* PROTOBUF_NONNULL value);
|
||||
enum StopDiscoveringError : int {
|
||||
STOP_DISCOVERING_FAILED = 31,
|
||||
STOP_LEGACY_DISCOVERING_FAILED = 32,
|
||||
STOP_EXTENDED_DISCOVERING_FAILED = 33,
|
||||
UNKNOWN_STOP_DISCOVERING_ERROR = 34
|
||||
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) {
|
||||
extern const uint32_t StopDiscoveringError_internal_data_[];
|
||||
inline constexpr StopDiscoveringError StopDiscoveringError_MIN =
|
||||
static_cast<StopDiscoveringError>(31);
|
||||
inline constexpr StopDiscoveringError StopDiscoveringError_MAX =
|
||||
static_cast<StopDiscoveringError>(34);
|
||||
inline bool StopDiscoveringError_IsValid(int value) {
|
||||
return 31 <= value && value <= 34;
|
||||
}
|
||||
inline constexpr int StopDiscoveringError_ARRAYSIZE = 34 + 1;
|
||||
const ::std::string& StopDiscoveringError_Name(StopDiscoveringError value);
|
||||
template <typename T>
|
||||
const ::std::string& StopDiscoveringError_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to StopDiscoveringError_Name().");
|
||||
return StopDiscoveringError_Name(static_cast<StopDiscoveringError>(value));
|
||||
}
|
||||
bool StopDiscoveringError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopDiscoveringError* value);
|
||||
::absl::string_view name, StopDiscoveringError* PROTOBUF_NONNULL value);
|
||||
enum StartListeningIncomingConnectionError : int {
|
||||
DUPLICATE_ACCEPTING_CONNECTION_REQUESTED = 31,
|
||||
OPEN_GATT_SERVER_FAILED = 32,
|
||||
@@ -249,42 +375,52 @@ enum StartListeningIncomingConnectionError : int {
|
||||
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
|
||||
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) {
|
||||
extern const uint32_t StartListeningIncomingConnectionError_internal_data_[];
|
||||
inline constexpr StartListeningIncomingConnectionError StartListeningIncomingConnectionError_MIN =
|
||||
static_cast<StartListeningIncomingConnectionError>(31);
|
||||
inline constexpr StartListeningIncomingConnectionError StartListeningIncomingConnectionError_MAX =
|
||||
static_cast<StartListeningIncomingConnectionError>(40);
|
||||
inline bool StartListeningIncomingConnectionError_IsValid(int value) {
|
||||
return 31 <= value && value <= 40;
|
||||
}
|
||||
inline constexpr int StartListeningIncomingConnectionError_ARRAYSIZE = 40 + 1;
|
||||
const ::std::string& StartListeningIncomingConnectionError_Name(StartListeningIncomingConnectionError value);
|
||||
template <typename T>
|
||||
const ::std::string& StartListeningIncomingConnectionError_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to StartListeningIncomingConnectionError_Name().");
|
||||
return StartListeningIncomingConnectionError_Name(static_cast<StartListeningIncomingConnectionError>(value));
|
||||
}
|
||||
bool StartListeningIncomingConnectionError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StartListeningIncomingConnectionError* value);
|
||||
::absl::string_view name, StartListeningIncomingConnectionError* PROTOBUF_NONNULL value);
|
||||
enum StopListeningIncomingConnectionError : int {
|
||||
STOP_ACCEPTING_CONNECTION_FAILED = 31,
|
||||
UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR = 32
|
||||
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) {
|
||||
extern const uint32_t StopListeningIncomingConnectionError_internal_data_[];
|
||||
inline constexpr StopListeningIncomingConnectionError StopListeningIncomingConnectionError_MIN =
|
||||
static_cast<StopListeningIncomingConnectionError>(31);
|
||||
inline constexpr StopListeningIncomingConnectionError StopListeningIncomingConnectionError_MAX =
|
||||
static_cast<StopListeningIncomingConnectionError>(32);
|
||||
inline bool StopListeningIncomingConnectionError_IsValid(int value) {
|
||||
return 31 <= value && value <= 32;
|
||||
}
|
||||
inline constexpr int StopListeningIncomingConnectionError_ARRAYSIZE = 32 + 1;
|
||||
const ::std::string& StopListeningIncomingConnectionError_Name(StopListeningIncomingConnectionError value);
|
||||
template <typename T>
|
||||
const ::std::string& StopListeningIncomingConnectionError_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to StopListeningIncomingConnectionError_Name().");
|
||||
return StopListeningIncomingConnectionError_Name(static_cast<StopListeningIncomingConnectionError>(value));
|
||||
}
|
||||
bool StopListeningIncomingConnectionError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopListeningIncomingConnectionError* value);
|
||||
::absl::string_view name, StopListeningIncomingConnectionError* PROTOBUF_NONNULL value);
|
||||
enum ConnectError : int {
|
||||
UNEXPECT_TARGET_LOST = 31,
|
||||
ESTABLISH_GATT_CONNECTION_FAILED = 32,
|
||||
@@ -301,137 +437,172 @@ enum ConnectError : int {
|
||||
CONNECT_TO_NETWORK_FAILED = 43,
|
||||
UNKNOWN_CONNECT_ERROR = 44,
|
||||
CONNECT_SEND_AWARE_L2_MESSAGE_FAILED = 45,
|
||||
CONNECT_READ_AWARE_L2_MESSAGE_FAILED = 46
|
||||
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) {
|
||||
extern const uint32_t ConnectError_internal_data_[];
|
||||
inline constexpr ConnectError ConnectError_MIN =
|
||||
static_cast<ConnectError>(31);
|
||||
inline constexpr ConnectError ConnectError_MAX =
|
||||
static_cast<ConnectError>(46);
|
||||
inline bool ConnectError_IsValid(int value) {
|
||||
return 31 <= value && value <= 46;
|
||||
}
|
||||
inline constexpr int ConnectError_ARRAYSIZE = 46 + 1;
|
||||
const ::std::string& ConnectError_Name(ConnectError value);
|
||||
template <typename T>
|
||||
const ::std::string& ConnectError_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to ConnectError_Name().");
|
||||
return ConnectError_Name(static_cast<ConnectError>(value));
|
||||
}
|
||||
bool ConnectError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectError* value);
|
||||
::absl::string_view name, ConnectError* PROTOBUF_NONNULL value);
|
||||
enum DisconnectError : int {
|
||||
DISCONNECT_NETWORK_FAILED = 31,
|
||||
UNKNOWN_DISCONNECT_ERROR = 32
|
||||
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) {
|
||||
extern const uint32_t DisconnectError_internal_data_[];
|
||||
inline constexpr DisconnectError DisconnectError_MIN =
|
||||
static_cast<DisconnectError>(31);
|
||||
inline constexpr DisconnectError DisconnectError_MAX =
|
||||
static_cast<DisconnectError>(32);
|
||||
inline bool DisconnectError_IsValid(int value) {
|
||||
return 31 <= value && value <= 32;
|
||||
}
|
||||
inline constexpr int DisconnectError_ARRAYSIZE = 32 + 1;
|
||||
const ::std::string& DisconnectError_Name(DisconnectError value);
|
||||
template <typename T>
|
||||
const ::std::string& DisconnectError_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to DisconnectError_Name().");
|
||||
return DisconnectError_Name(static_cast<DisconnectError>(value));
|
||||
}
|
||||
bool DisconnectError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DisconnectError* value);
|
||||
::absl::string_view name, DisconnectError* PROTOBUF_NONNULL value);
|
||||
enum SendPayloadError : int {
|
||||
UNKNOWN_SEND_PAYLOAD_ERROR = 31,
|
||||
SEND_PAYLOAD_FAILED = 32
|
||||
SEND_PAYLOAD_FAILED = 32,
|
||||
};
|
||||
bool SendPayloadError_IsValid(int value);
|
||||
constexpr SendPayloadError SendPayloadError_MIN = UNKNOWN_SEND_PAYLOAD_ERROR;
|
||||
constexpr SendPayloadError SendPayloadError_MAX = SEND_PAYLOAD_FAILED;
|
||||
constexpr int SendPayloadError_ARRAYSIZE = SendPayloadError_MAX + 1;
|
||||
|
||||
const std::string& SendPayloadError_Name(SendPayloadError value);
|
||||
template<typename T>
|
||||
inline const std::string& SendPayloadError_Name(T enum_t_value) {
|
||||
extern const uint32_t SendPayloadError_internal_data_[];
|
||||
inline constexpr SendPayloadError SendPayloadError_MIN =
|
||||
static_cast<SendPayloadError>(31);
|
||||
inline constexpr SendPayloadError SendPayloadError_MAX =
|
||||
static_cast<SendPayloadError>(32);
|
||||
inline bool SendPayloadError_IsValid(int value) {
|
||||
return 31 <= value && value <= 32;
|
||||
}
|
||||
inline constexpr int SendPayloadError_ARRAYSIZE = 32 + 1;
|
||||
const ::std::string& SendPayloadError_Name(SendPayloadError value);
|
||||
template <typename T>
|
||||
const ::std::string& SendPayloadError_Name(T value) {
|
||||
static_assert(::std::is_same<T, SendPayloadError>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function SendPayloadError_Name.");
|
||||
return SendPayloadError_Name(static_cast<SendPayloadError>(enum_t_value));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to SendPayloadError_Name().");
|
||||
return SendPayloadError_Name(static_cast<SendPayloadError>(value));
|
||||
}
|
||||
bool SendPayloadError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SendPayloadError* value);
|
||||
::absl::string_view name, SendPayloadError* PROTOBUF_NONNULL value);
|
||||
enum ReceivePayloadError : int {
|
||||
UNKNOWN_RECEIVE_PAYLOAD_ERROR = 31,
|
||||
RECEIVE_PAYLOAD_FAILED = 32
|
||||
RECEIVE_PAYLOAD_FAILED = 32,
|
||||
};
|
||||
bool ReceivePayloadError_IsValid(int value);
|
||||
constexpr ReceivePayloadError ReceivePayloadError_MIN = UNKNOWN_RECEIVE_PAYLOAD_ERROR;
|
||||
constexpr ReceivePayloadError ReceivePayloadError_MAX = RECEIVE_PAYLOAD_FAILED;
|
||||
constexpr int ReceivePayloadError_ARRAYSIZE = ReceivePayloadError_MAX + 1;
|
||||
|
||||
const std::string& ReceivePayloadError_Name(ReceivePayloadError value);
|
||||
template<typename T>
|
||||
inline const std::string& ReceivePayloadError_Name(T enum_t_value) {
|
||||
extern const uint32_t ReceivePayloadError_internal_data_[];
|
||||
inline constexpr ReceivePayloadError ReceivePayloadError_MIN =
|
||||
static_cast<ReceivePayloadError>(31);
|
||||
inline constexpr ReceivePayloadError ReceivePayloadError_MAX =
|
||||
static_cast<ReceivePayloadError>(32);
|
||||
inline bool ReceivePayloadError_IsValid(int value) {
|
||||
return 31 <= value && value <= 32;
|
||||
}
|
||||
inline constexpr int ReceivePayloadError_ARRAYSIZE = 32 + 1;
|
||||
const ::std::string& ReceivePayloadError_Name(ReceivePayloadError value);
|
||||
template <typename T>
|
||||
const ::std::string& ReceivePayloadError_Name(T value) {
|
||||
static_assert(::std::is_same<T, ReceivePayloadError>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function ReceivePayloadError_Name.");
|
||||
return ReceivePayloadError_Name(static_cast<ReceivePayloadError>(enum_t_value));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to ReceivePayloadError_Name().");
|
||||
return ReceivePayloadError_Name(static_cast<ReceivePayloadError>(value));
|
||||
}
|
||||
bool ReceivePayloadError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReceivePayloadError* value);
|
||||
::absl::string_view name, ReceivePayloadError* PROTOBUF_NONNULL value);
|
||||
enum UpgradeError : int {
|
||||
UNKNOWN_UPGRADE_ERROR = 31,
|
||||
CREATE_P2P_GROUP_FAILED = 32
|
||||
CREATE_P2P_GROUP_FAILED = 32,
|
||||
};
|
||||
bool UpgradeError_IsValid(int value);
|
||||
constexpr UpgradeError UpgradeError_MIN = UNKNOWN_UPGRADE_ERROR;
|
||||
constexpr UpgradeError UpgradeError_MAX = CREATE_P2P_GROUP_FAILED;
|
||||
constexpr int UpgradeError_ARRAYSIZE = UpgradeError_MAX + 1;
|
||||
|
||||
const std::string& UpgradeError_Name(UpgradeError value);
|
||||
template<typename T>
|
||||
inline const std::string& UpgradeError_Name(T enum_t_value) {
|
||||
extern const uint32_t UpgradeError_internal_data_[];
|
||||
inline constexpr UpgradeError UpgradeError_MIN =
|
||||
static_cast<UpgradeError>(31);
|
||||
inline constexpr UpgradeError UpgradeError_MAX =
|
||||
static_cast<UpgradeError>(32);
|
||||
inline bool UpgradeError_IsValid(int value) {
|
||||
return 31 <= value && value <= 32;
|
||||
}
|
||||
inline constexpr int UpgradeError_ARRAYSIZE = 32 + 1;
|
||||
const ::std::string& UpgradeError_Name(UpgradeError value);
|
||||
template <typename T>
|
||||
const ::std::string& UpgradeError_Name(T value) {
|
||||
static_assert(::std::is_same<T, UpgradeError>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function UpgradeError_Name.");
|
||||
return UpgradeError_Name(static_cast<UpgradeError>(enum_t_value));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to UpgradeError_Name().");
|
||||
return UpgradeError_Name(static_cast<UpgradeError>(value));
|
||||
}
|
||||
bool UpgradeError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, UpgradeError* value);
|
||||
::absl::string_view name, UpgradeError* PROTOBUF_NONNULL value);
|
||||
enum AcceptConnectionError : int {
|
||||
UNKNOWN_ACCEPT_CONNECTION_ERROR = 31,
|
||||
RESPOND_ACCEPT_CONNECTION_FAILED = 32
|
||||
RESPOND_ACCEPT_CONNECTION_FAILED = 32,
|
||||
};
|
||||
bool AcceptConnectionError_IsValid(int value);
|
||||
constexpr AcceptConnectionError AcceptConnectionError_MIN = UNKNOWN_ACCEPT_CONNECTION_ERROR;
|
||||
constexpr AcceptConnectionError AcceptConnectionError_MAX = RESPOND_ACCEPT_CONNECTION_FAILED;
|
||||
constexpr int AcceptConnectionError_ARRAYSIZE = AcceptConnectionError_MAX + 1;
|
||||
|
||||
const std::string& AcceptConnectionError_Name(AcceptConnectionError value);
|
||||
template<typename T>
|
||||
inline const std::string& AcceptConnectionError_Name(T enum_t_value) {
|
||||
extern const uint32_t AcceptConnectionError_internal_data_[];
|
||||
inline constexpr AcceptConnectionError AcceptConnectionError_MIN =
|
||||
static_cast<AcceptConnectionError>(31);
|
||||
inline constexpr AcceptConnectionError AcceptConnectionError_MAX =
|
||||
static_cast<AcceptConnectionError>(32);
|
||||
inline bool AcceptConnectionError_IsValid(int value) {
|
||||
return 31 <= value && value <= 32;
|
||||
}
|
||||
inline constexpr int AcceptConnectionError_ARRAYSIZE = 32 + 1;
|
||||
const ::std::string& AcceptConnectionError_Name(AcceptConnectionError value);
|
||||
template <typename T>
|
||||
const ::std::string& AcceptConnectionError_Name(T value) {
|
||||
static_assert(::std::is_same<T, AcceptConnectionError>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function AcceptConnectionError_Name.");
|
||||
return AcceptConnectionError_Name(static_cast<AcceptConnectionError>(enum_t_value));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to AcceptConnectionError_Name().");
|
||||
return AcceptConnectionError_Name(static_cast<AcceptConnectionError>(value));
|
||||
}
|
||||
bool AcceptConnectionError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AcceptConnectionError* value);
|
||||
::absl::string_view name, AcceptConnectionError* PROTOBUF_NONNULL value);
|
||||
enum RejectConnectionError : int {
|
||||
UNKNOWN_REJECT_CONNECTION_ERROR = 31,
|
||||
RESPOND_REJECT_CONNECTION_FAILED = 32
|
||||
RESPOND_REJECT_CONNECTION_FAILED = 32,
|
||||
};
|
||||
bool RejectConnectionError_IsValid(int value);
|
||||
constexpr RejectConnectionError RejectConnectionError_MIN = UNKNOWN_REJECT_CONNECTION_ERROR;
|
||||
constexpr RejectConnectionError RejectConnectionError_MAX = RESPOND_REJECT_CONNECTION_FAILED;
|
||||
constexpr int RejectConnectionError_ARRAYSIZE = RejectConnectionError_MAX + 1;
|
||||
|
||||
const std::string& RejectConnectionError_Name(RejectConnectionError value);
|
||||
template<typename T>
|
||||
inline const std::string& RejectConnectionError_Name(T enum_t_value) {
|
||||
extern const uint32_t RejectConnectionError_internal_data_[];
|
||||
inline constexpr RejectConnectionError RejectConnectionError_MIN =
|
||||
static_cast<RejectConnectionError>(31);
|
||||
inline constexpr RejectConnectionError RejectConnectionError_MAX =
|
||||
static_cast<RejectConnectionError>(32);
|
||||
inline bool RejectConnectionError_IsValid(int value) {
|
||||
return 31 <= value && value <= 32;
|
||||
}
|
||||
inline constexpr int RejectConnectionError_ARRAYSIZE = 32 + 1;
|
||||
const ::std::string& RejectConnectionError_Name(RejectConnectionError value);
|
||||
template <typename T>
|
||||
const ::std::string& RejectConnectionError_Name(T value) {
|
||||
static_assert(::std::is_same<T, RejectConnectionError>::value ||
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to function RejectConnectionError_Name.");
|
||||
return RejectConnectionError_Name(static_cast<RejectConnectionError>(enum_t_value));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to RejectConnectionError_Name().");
|
||||
return RejectConnectionError_Name(static_cast<RejectConnectionError>(value));
|
||||
}
|
||||
bool RejectConnectionError_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RejectConnectionError* value);
|
||||
::absl::string_view name, RejectConnectionError* PROTOBUF_NONNULL value);
|
||||
enum Description : int {
|
||||
UNKNOWN = 0,
|
||||
NULL_SERVICE_ID = 1,
|
||||
@@ -618,69 +789,99 @@ enum Description : int {
|
||||
MULTIPLEX_SOCKET_IOEXCEPTION = 184,
|
||||
MULTIPLEX_SOCKET_UNKNOWN_RESPONSE_CODE = 185,
|
||||
MULTIPLEX_SOCKET_EXECUTION_EXCEPTION = 186,
|
||||
MULTIPLEX_SOCKET_INTERRUPTED_EXCEPTION = 187
|
||||
MULTIPLEX_SOCKET_INTERRUPTED_EXCEPTION = 187,
|
||||
};
|
||||
bool Description_IsValid(int value);
|
||||
constexpr Description Description_MIN = UNKNOWN;
|
||||
constexpr Description Description_MAX = MULTIPLEX_SOCKET_INTERRUPTED_EXCEPTION;
|
||||
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) {
|
||||
extern const uint32_t Description_internal_data_[];
|
||||
inline constexpr Description Description_MIN =
|
||||
static_cast<Description>(0);
|
||||
inline constexpr Description Description_MAX =
|
||||
static_cast<Description>(187);
|
||||
inline bool Description_IsValid(int value) {
|
||||
return ::google::protobuf::internal::ValidateEnum(value, Description_internal_data_);
|
||||
}
|
||||
inline constexpr int Description_ARRAYSIZE = 187 + 1;
|
||||
const ::std::string& Description_Name(Description value);
|
||||
template <typename T>
|
||||
const ::std::string& Description_Name(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));
|
||||
::std::is_integral<T>::value,
|
||||
"Incorrect type passed to Description_Name().");
|
||||
return Description_Name(static_cast<Description>(value));
|
||||
}
|
||||
bool Description_Parse(
|
||||
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Description* value);
|
||||
::absl::string_view name, Description* PROTOBUF_NONNULL value);
|
||||
|
||||
// ===================================================================
|
||||
|
||||
|
||||
|
||||
// ===================================================================
|
||||
|
||||
|
||||
|
||||
|
||||
// ===================================================================
|
||||
|
||||
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
||||
#endif // __GNUC__
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic pop
|
||||
#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::SendPayloadError> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::ReceivePayloadError> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::UpgradeError> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::AcceptConnectionError> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::RejectConnectionError> : ::std::true_type {};
|
||||
template <> struct is_proto_enum< ::location::nearby::errorcode::proto::Description> : ::std::true_type {};
|
||||
namespace google {
|
||||
namespace protobuf {
|
||||
|
||||
PROTOBUF_NAMESPACE_CLOSE
|
||||
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::SendPayloadError> : std::true_type {};
|
||||
template <>
|
||||
struct is_proto_enum<::location::nearby::errorcode::proto::ReceivePayloadError> : std::true_type {};
|
||||
template <>
|
||||
struct is_proto_enum<::location::nearby::errorcode::proto::UpgradeError> : std::true_type {};
|
||||
template <>
|
||||
struct is_proto_enum<::location::nearby::errorcode::proto::AcceptConnectionError> : std::true_type {};
|
||||
template <>
|
||||
struct is_proto_enum<::location::nearby::errorcode::proto::RejectConnectionError> : std::true_type {};
|
||||
template <>
|
||||
struct is_proto_enum<::location::nearby::errorcode::proto::Description> : std::true_type {};
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
// @@protoc_insertion_point(global_scope)
|
||||
|
||||
#include <google/protobuf/port_undef.inc>
|
||||
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
|
||||
#include "google/protobuf/port_undef.inc"
|
||||
|
||||
#endif // proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto_2epb_2eh
|
||||
|
||||
Reference in New Issue
Block a user