TySS-Dev/nearby
1
0
Fork 0
mirror of https://github.com/kidfromjupiter/nearby.git synced 2026-09-14 22:56:12 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
b1938b6fdb697d1cd8a5dec00f2dcf482ec9aabc
nearby/compiled_proto/proto/errorcode/error_code_enums.pb.h
T

888 lines
36 KiB
C++
Raw Blame History

// 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 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/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
#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)
// Must be included last.
#include "google/protobuf/port_def.inc"
#define PROTOBUF_INTERNAL_EXPORT_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto
namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
} // namespace internal
} // namespace protobuf
} // namespace google
// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto {
static const ::uint32_t offsets[];
};
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,
};
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 ErrorType_Name().");
return ErrorType_Name(static_cast<ErrorType>(value));
}
bool ErrorType_Parse(
::absl::string_view name, ErrorType* PROTOBUF_NONNULL 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,
UPGRADE = 14,
};
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 Event_Name().");
return Event_Name(static_cast<Event>(value));
}
bool Event_Parse(
::absl::string_view name, Event* PROTOBUF_NONNULL 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,
};
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 CommonError_Name().");
return CommonError_Name(static_cast<CommonError>(value));
}
bool CommonError_Parse(
::absl::string_view name, CommonError* PROTOBUF_NONNULL 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,
};
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 StartAdvertisingError_Name().");
return StartAdvertisingError_Name(static_cast<StartAdvertisingError>(value));
}
bool StartAdvertisingError_Parse(
::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,
};
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 StopAdvertisingError_Name().");
return StopAdvertisingError_Name(static_cast<StopAdvertisingError>(value));
}
bool StopAdvertisingError_Parse(
::absl::string_view name, StopAdvertisingError* PROTOBUF_NONNULL 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,
};
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 StartDiscoveringError_Name().");
return StartDiscoveringError_Name(static_cast<StartDiscoveringError>(value));
}
bool StartDiscoveringError_Parse(
::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,
};
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 StopDiscoveringError_Name().");
return StopDiscoveringError_Name(static_cast<StopDiscoveringError>(value));
}
bool StopDiscoveringError_Parse(
::absl::string_view name, StopDiscoveringError* PROTOBUF_NONNULL 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,
};
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 StartListeningIncomingConnectionError_Name().");
return StartListeningIncomingConnectionError_Name(static_cast<StartListeningIncomingConnectionError>(value));
}
bool StartListeningIncomingConnectionError_Parse(
::absl::string_view name, StartListeningIncomingConnectionError* PROTOBUF_NONNULL value);
enum StopListeningIncomingConnectionError : int {
STOP_ACCEPTING_CONNECTION_FAILED = 31,
UNKNOWN_STOP_LISTENING_INCOMING_CONNECTION_ERROR = 32,
};
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 StopListeningIncomingConnectionError_Name().");
return StopListeningIncomingConnectionError_Name(static_cast<StopListeningIncomingConnectionError>(value));
}
bool StopListeningIncomingConnectionError_Parse(
::absl::string_view name, StopListeningIncomingConnectionError* PROTOBUF_NONNULL 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,
};
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 ConnectError_Name().");
return ConnectError_Name(static_cast<ConnectError>(value));
}
bool ConnectError_Parse(
::absl::string_view name, ConnectError* PROTOBUF_NONNULL value);
enum DisconnectError : int {
DISCONNECT_NETWORK_FAILED = 31,
UNKNOWN_DISCONNECT_ERROR = 32,
};
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 DisconnectError_Name().");
return DisconnectError_Name(static_cast<DisconnectError>(value));
}
bool DisconnectError_Parse(
::absl::string_view name, DisconnectError* PROTOBUF_NONNULL value);
enum SendPayloadError : int {
UNKNOWN_SEND_PAYLOAD_ERROR = 31,
SEND_PAYLOAD_FAILED = 32,
};
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 SendPayloadError_Name().");
return SendPayloadError_Name(static_cast<SendPayloadError>(value));
}
bool SendPayloadError_Parse(
::absl::string_view name, SendPayloadError* PROTOBUF_NONNULL value);
enum ReceivePayloadError : int {
UNKNOWN_RECEIVE_PAYLOAD_ERROR = 31,
RECEIVE_PAYLOAD_FAILED = 32,
};
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 ReceivePayloadError_Name().");
return ReceivePayloadError_Name(static_cast<ReceivePayloadError>(value));
}
bool ReceivePayloadError_Parse(
::absl::string_view name, ReceivePayloadError* PROTOBUF_NONNULL value);
enum UpgradeError : int {
UNKNOWN_UPGRADE_ERROR = 31,
CREATE_P2P_GROUP_FAILED = 32,
};
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 UpgradeError_Name().");
return UpgradeError_Name(static_cast<UpgradeError>(value));
}
bool UpgradeError_Parse(
::absl::string_view name, UpgradeError* PROTOBUF_NONNULL value);
enum AcceptConnectionError : int {
UNKNOWN_ACCEPT_CONNECTION_ERROR = 31,
RESPOND_ACCEPT_CONNECTION_FAILED = 32,
};
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 AcceptConnectionError_Name().");
return AcceptConnectionError_Name(static_cast<AcceptConnectionError>(value));
}
bool AcceptConnectionError_Parse(
::absl::string_view name, AcceptConnectionError* PROTOBUF_NONNULL value);
enum RejectConnectionError : int {
UNKNOWN_REJECT_CONNECTION_ERROR = 31,
RESPOND_REJECT_CONNECTION_FAILED = 32,
};
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 RejectConnectionError_Name().");
return RejectConnectionError_Name(static_cast<RejectConnectionError>(value));
}
bool RejectConnectionError_Parse(
::absl::string_view name, RejectConnectionError* PROTOBUF_NONNULL 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,
USER_RESTRICTION_DISALLOWED = 172,
UNSUPPORTED_DEVICE_TYPE_PHONE = 173,
UNSUPPORTED_DEVICE_TYPE_TABLET = 174,
BROKEN_PIPE = 175,
CONNECTION_ABORT = 176,
FEATURE_USB_HOST_NOT_SUPPORTED = 177,
FEATURE_USB_ACCESSORY_NOT_SUPPORTED = 178,
FEATURE_USB_PORTS_NOT_FOUND = 179,
MULTIPLEX_SOCKET_UNKNOWN_ERROR = 180,
MULTIPLEX_SOCKET_NOT_LISTENING = 181,
MULTIPLEX_SOCKET_DISABLED = 182,
MULTIPLEX_SOCKET_TIMEOUT = 183,
MULTIPLEX_SOCKET_IOEXCEPTION = 184,
MULTIPLEX_SOCKET_UNKNOWN_RESPONSE_CODE = 185,
MULTIPLEX_SOCKET_EXECUTION_EXCEPTION = 186,
MULTIPLEX_SOCKET_INTERRUPTED_EXCEPTION = 187,
};
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 Description_Name().");
return Description_Name(static_cast<Description>(value));
}
bool Description_Parse(
::absl::string_view name, Description* PROTOBUF_NONNULL 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
namespace google {
namespace protobuf {
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 // proto_2ferrorcode_2ferror_5fcode_5fenums_2eproto_2epb_2eh
Reference in New Issue View Git Blame Copy Permalink