mirror of
https://github.com/kidfromjupiter/nearby.git
synced 2026-09-14 14:46:12 -04:00
2093 lines
80 KiB
C++
2093 lines
80 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: proto/mediums/multiplex_frames.proto
|
|
|
|
#include "proto/mediums/multiplex_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 MultiplexFrame::MultiplexFrame(
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
|
|
: header_(nullptr)
|
|
, frame_type_(0)
|
|
|
|
, _oneof_case_{}{}
|
|
struct MultiplexFrameDefaultTypeInternal {
|
|
constexpr MultiplexFrameDefaultTypeInternal()
|
|
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
|
|
~MultiplexFrameDefaultTypeInternal() {}
|
|
union {
|
|
MultiplexFrame _instance;
|
|
};
|
|
};
|
|
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MultiplexFrameDefaultTypeInternal _MultiplexFrame_default_instance_;
|
|
constexpr MultiplexFrameHeader::MultiplexFrameHeader(
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
|
|
: salted_service_id_hash_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
|
|
, service_id_hash_salt_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
|
|
struct MultiplexFrameHeaderDefaultTypeInternal {
|
|
constexpr MultiplexFrameHeaderDefaultTypeInternal()
|
|
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
|
|
~MultiplexFrameHeaderDefaultTypeInternal() {}
|
|
union {
|
|
MultiplexFrameHeader _instance;
|
|
};
|
|
};
|
|
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MultiplexFrameHeaderDefaultTypeInternal _MultiplexFrameHeader_default_instance_;
|
|
constexpr MultiplexControlFrame::MultiplexControlFrame(
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
|
|
: control_frame_type_(0)
|
|
|
|
, _oneof_case_{}{}
|
|
struct MultiplexControlFrameDefaultTypeInternal {
|
|
constexpr MultiplexControlFrameDefaultTypeInternal()
|
|
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
|
|
~MultiplexControlFrameDefaultTypeInternal() {}
|
|
union {
|
|
MultiplexControlFrame _instance;
|
|
};
|
|
};
|
|
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MultiplexControlFrameDefaultTypeInternal _MultiplexControlFrame_default_instance_;
|
|
constexpr ConnectionRequestFrame::ConnectionRequestFrame(
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
|
|
struct ConnectionRequestFrameDefaultTypeInternal {
|
|
constexpr ConnectionRequestFrameDefaultTypeInternal()
|
|
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
|
|
~ConnectionRequestFrameDefaultTypeInternal() {}
|
|
union {
|
|
ConnectionRequestFrame _instance;
|
|
};
|
|
};
|
|
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionRequestFrameDefaultTypeInternal _ConnectionRequestFrame_default_instance_;
|
|
constexpr ConnectionResponseFrame::ConnectionResponseFrame(
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
|
|
: connection_response_code_(0)
|
|
{}
|
|
struct ConnectionResponseFrameDefaultTypeInternal {
|
|
constexpr ConnectionResponseFrameDefaultTypeInternal()
|
|
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
|
|
~ConnectionResponseFrameDefaultTypeInternal() {}
|
|
union {
|
|
ConnectionResponseFrame _instance;
|
|
};
|
|
};
|
|
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ConnectionResponseFrameDefaultTypeInternal _ConnectionResponseFrame_default_instance_;
|
|
constexpr DisconnectFrame::DisconnectFrame(
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
|
|
struct DisconnectFrameDefaultTypeInternal {
|
|
constexpr DisconnectFrameDefaultTypeInternal()
|
|
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
|
|
~DisconnectFrameDefaultTypeInternal() {}
|
|
union {
|
|
DisconnectFrame _instance;
|
|
};
|
|
};
|
|
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DisconnectFrameDefaultTypeInternal _DisconnectFrame_default_instance_;
|
|
constexpr MultiplexDataFrame::MultiplexDataFrame(
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
|
|
: data_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
|
|
struct MultiplexDataFrameDefaultTypeInternal {
|
|
constexpr MultiplexDataFrameDefaultTypeInternal()
|
|
: _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
|
|
~MultiplexDataFrameDefaultTypeInternal() {}
|
|
union {
|
|
MultiplexDataFrame _instance;
|
|
};
|
|
};
|
|
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MultiplexDataFrameDefaultTypeInternal _MultiplexDataFrame_default_instance_;
|
|
} // namespace mediums
|
|
} // namespace nearby
|
|
} // namespace location
|
|
namespace location {
|
|
namespace nearby {
|
|
namespace mediums {
|
|
bool MultiplexFrame_MultiplexFrameType_IsValid(int value) {
|
|
switch (value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MultiplexFrame_MultiplexFrameType_strings[3] = {};
|
|
|
|
static const char MultiplexFrame_MultiplexFrameType_names[] =
|
|
"CONTROL_FRAME"
|
|
"DATA_FRAME"
|
|
"UNKNOWN_FRAME_TYPE";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MultiplexFrame_MultiplexFrameType_entries[] = {
|
|
{ {MultiplexFrame_MultiplexFrameType_names + 0, 13}, 1 },
|
|
{ {MultiplexFrame_MultiplexFrameType_names + 13, 10}, 2 },
|
|
{ {MultiplexFrame_MultiplexFrameType_names + 23, 18}, 0 },
|
|
};
|
|
|
|
static const int MultiplexFrame_MultiplexFrameType_entries_by_number[] = {
|
|
2, // 0 -> UNKNOWN_FRAME_TYPE
|
|
0, // 1 -> CONTROL_FRAME
|
|
1, // 2 -> DATA_FRAME
|
|
};
|
|
|
|
const std::string& MultiplexFrame_MultiplexFrameType_Name(
|
|
MultiplexFrame_MultiplexFrameType value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
MultiplexFrame_MultiplexFrameType_entries,
|
|
MultiplexFrame_MultiplexFrameType_entries_by_number,
|
|
3, MultiplexFrame_MultiplexFrameType_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
MultiplexFrame_MultiplexFrameType_entries,
|
|
MultiplexFrame_MultiplexFrameType_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
MultiplexFrame_MultiplexFrameType_strings[idx].get();
|
|
}
|
|
bool MultiplexFrame_MultiplexFrameType_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiplexFrame_MultiplexFrameType* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
MultiplexFrame_MultiplexFrameType_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<MultiplexFrame_MultiplexFrameType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
|
|
constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::UNKNOWN_FRAME_TYPE;
|
|
constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::CONTROL_FRAME;
|
|
constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::DATA_FRAME;
|
|
constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::MultiplexFrameType_MIN;
|
|
constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame::MultiplexFrameType_MAX;
|
|
constexpr int MultiplexFrame::MultiplexFrameType_ARRAYSIZE;
|
|
#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
|
|
bool MultiplexControlFrame_MultiplexControlFrameType_IsValid(int value) {
|
|
switch (value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> MultiplexControlFrame_MultiplexControlFrameType_strings[4] = {};
|
|
|
|
static const char MultiplexControlFrame_MultiplexControlFrameType_names[] =
|
|
"CONNECTION_REQUEST"
|
|
"CONNECTION_RESPONSE"
|
|
"DISCONNECTION"
|
|
"UNKNOWN_CONTROL_FRAME_TYPE";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry MultiplexControlFrame_MultiplexControlFrameType_entries[] = {
|
|
{ {MultiplexControlFrame_MultiplexControlFrameType_names + 0, 18}, 1 },
|
|
{ {MultiplexControlFrame_MultiplexControlFrameType_names + 18, 19}, 2 },
|
|
{ {MultiplexControlFrame_MultiplexControlFrameType_names + 37, 13}, 3 },
|
|
{ {MultiplexControlFrame_MultiplexControlFrameType_names + 50, 26}, 0 },
|
|
};
|
|
|
|
static const int MultiplexControlFrame_MultiplexControlFrameType_entries_by_number[] = {
|
|
3, // 0 -> UNKNOWN_CONTROL_FRAME_TYPE
|
|
0, // 1 -> CONNECTION_REQUEST
|
|
1, // 2 -> CONNECTION_RESPONSE
|
|
2, // 3 -> DISCONNECTION
|
|
};
|
|
|
|
const std::string& MultiplexControlFrame_MultiplexControlFrameType_Name(
|
|
MultiplexControlFrame_MultiplexControlFrameType value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
MultiplexControlFrame_MultiplexControlFrameType_entries,
|
|
MultiplexControlFrame_MultiplexControlFrameType_entries_by_number,
|
|
4, MultiplexControlFrame_MultiplexControlFrameType_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
MultiplexControlFrame_MultiplexControlFrameType_entries,
|
|
MultiplexControlFrame_MultiplexControlFrameType_entries_by_number,
|
|
4, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
MultiplexControlFrame_MultiplexControlFrameType_strings[idx].get();
|
|
}
|
|
bool MultiplexControlFrame_MultiplexControlFrameType_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiplexControlFrame_MultiplexControlFrameType* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
MultiplexControlFrame_MultiplexControlFrameType_entries, 4, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<MultiplexControlFrame_MultiplexControlFrameType>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
|
|
constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::UNKNOWN_CONTROL_FRAME_TYPE;
|
|
constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::CONNECTION_REQUEST;
|
|
constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::CONNECTION_RESPONSE;
|
|
constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::DISCONNECTION;
|
|
constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::MultiplexControlFrameType_MIN;
|
|
constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::MultiplexControlFrameType_MAX;
|
|
constexpr int MultiplexControlFrame::MultiplexControlFrameType_ARRAYSIZE;
|
|
#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
|
|
bool ConnectionResponseFrame_ConnectionResponseCode_IsValid(int value) {
|
|
switch (value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ConnectionResponseFrame_ConnectionResponseCode_strings[3] = {};
|
|
|
|
static const char ConnectionResponseFrame_ConnectionResponseCode_names[] =
|
|
"CONNECTION_ACCEPTED"
|
|
"NOT_LISTENING"
|
|
"UNKNOWN_RESPONSE_CODE";
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ConnectionResponseFrame_ConnectionResponseCode_entries[] = {
|
|
{ {ConnectionResponseFrame_ConnectionResponseCode_names + 0, 19}, 1 },
|
|
{ {ConnectionResponseFrame_ConnectionResponseCode_names + 19, 13}, 2 },
|
|
{ {ConnectionResponseFrame_ConnectionResponseCode_names + 32, 21}, 0 },
|
|
};
|
|
|
|
static const int ConnectionResponseFrame_ConnectionResponseCode_entries_by_number[] = {
|
|
2, // 0 -> UNKNOWN_RESPONSE_CODE
|
|
0, // 1 -> CONNECTION_ACCEPTED
|
|
1, // 2 -> NOT_LISTENING
|
|
};
|
|
|
|
const std::string& ConnectionResponseFrame_ConnectionResponseCode_Name(
|
|
ConnectionResponseFrame_ConnectionResponseCode value) {
|
|
static const bool dummy =
|
|
::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
|
|
ConnectionResponseFrame_ConnectionResponseCode_entries,
|
|
ConnectionResponseFrame_ConnectionResponseCode_entries_by_number,
|
|
3, ConnectionResponseFrame_ConnectionResponseCode_strings);
|
|
(void) dummy;
|
|
int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
|
|
ConnectionResponseFrame_ConnectionResponseCode_entries,
|
|
ConnectionResponseFrame_ConnectionResponseCode_entries_by_number,
|
|
3, value);
|
|
return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
|
|
ConnectionResponseFrame_ConnectionResponseCode_strings[idx].get();
|
|
}
|
|
bool ConnectionResponseFrame_ConnectionResponseCode_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionResponseFrame_ConnectionResponseCode* value) {
|
|
int int_value;
|
|
bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
|
|
ConnectionResponseFrame_ConnectionResponseCode_entries, 3, name, &int_value);
|
|
if (success) {
|
|
*value = static_cast<ConnectionResponseFrame_ConnectionResponseCode>(int_value);
|
|
}
|
|
return success;
|
|
}
|
|
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
|
|
constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::UNKNOWN_RESPONSE_CODE;
|
|
constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::CONNECTION_ACCEPTED;
|
|
constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::NOT_LISTENING;
|
|
constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::ConnectionResponseCode_MIN;
|
|
constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::ConnectionResponseCode_MAX;
|
|
constexpr int ConnectionResponseFrame::ConnectionResponseCode_ARRAYSIZE;
|
|
#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
|
|
|
|
// ===================================================================
|
|
|
|
class MultiplexFrame::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<MultiplexFrame>()._has_bits_);
|
|
static const ::location::nearby::mediums::MultiplexFrameHeader& header(const MultiplexFrame* msg);
|
|
static void set_has_header(HasBits* has_bits) {
|
|
(*has_bits)[0] |= 1u;
|
|
}
|
|
static void set_has_frame_type(HasBits* has_bits) {
|
|
(*has_bits)[0] |= 2u;
|
|
}
|
|
static const ::location::nearby::mediums::MultiplexControlFrame& control_frame(const MultiplexFrame* msg);
|
|
static const ::location::nearby::mediums::MultiplexDataFrame& data_frame(const MultiplexFrame* msg);
|
|
};
|
|
|
|
const ::location::nearby::mediums::MultiplexFrameHeader&
|
|
MultiplexFrame::_Internal::header(const MultiplexFrame* msg) {
|
|
return *msg->header_;
|
|
}
|
|
const ::location::nearby::mediums::MultiplexControlFrame&
|
|
MultiplexFrame::_Internal::control_frame(const MultiplexFrame* msg) {
|
|
return *msg->Frame_.control_frame_;
|
|
}
|
|
const ::location::nearby::mediums::MultiplexDataFrame&
|
|
MultiplexFrame::_Internal::data_frame(const MultiplexFrame* msg) {
|
|
return *msg->Frame_.data_frame_;
|
|
}
|
|
void MultiplexFrame::set_allocated_control_frame(::location::nearby::mediums::MultiplexControlFrame* control_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
clear_Frame();
|
|
if (control_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::MultiplexControlFrame>::GetOwningArena(control_frame);
|
|
if (message_arena != submessage_arena) {
|
|
control_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, control_frame, submessage_arena);
|
|
}
|
|
set_has_control_frame();
|
|
Frame_.control_frame_ = control_frame;
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrame.control_frame)
|
|
}
|
|
void MultiplexFrame::set_allocated_data_frame(::location::nearby::mediums::MultiplexDataFrame* data_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
clear_Frame();
|
|
if (data_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::MultiplexDataFrame>::GetOwningArena(data_frame);
|
|
if (message_arena != submessage_arena) {
|
|
data_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, data_frame, submessage_arena);
|
|
}
|
|
set_has_data_frame();
|
|
Frame_.data_frame_ = data_frame;
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrame.data_frame)
|
|
}
|
|
MultiplexFrame::MultiplexFrame(::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.MultiplexFrame)
|
|
}
|
|
MultiplexFrame::MultiplexFrame(const MultiplexFrame& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
if (from._internal_has_header()) {
|
|
header_ = new ::location::nearby::mediums::MultiplexFrameHeader(*from.header_);
|
|
} else {
|
|
header_ = nullptr;
|
|
}
|
|
frame_type_ = from.frame_type_;
|
|
clear_has_Frame();
|
|
switch (from.Frame_case()) {
|
|
case kControlFrame: {
|
|
_internal_mutable_control_frame()->::location::nearby::mediums::MultiplexControlFrame::MergeFrom(from._internal_control_frame());
|
|
break;
|
|
}
|
|
case kDataFrame: {
|
|
_internal_mutable_data_frame()->::location::nearby::mediums::MultiplexDataFrame::MergeFrom(from._internal_data_frame());
|
|
break;
|
|
}
|
|
case FRAME_NOT_SET: {
|
|
break;
|
|
}
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:location.nearby.mediums.MultiplexFrame)
|
|
}
|
|
|
|
inline void MultiplexFrame::SharedCtor() {
|
|
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
|
|
reinterpret_cast<char*>(&header_) - reinterpret_cast<char*>(this)),
|
|
0, static_cast<size_t>(reinterpret_cast<char*>(&frame_type_) -
|
|
reinterpret_cast<char*>(&header_)) + sizeof(frame_type_));
|
|
clear_has_Frame();
|
|
}
|
|
|
|
MultiplexFrame::~MultiplexFrame() {
|
|
// @@protoc_insertion_point(destructor:location.nearby.mediums.MultiplexFrame)
|
|
if (GetArenaForAllocation() != nullptr) return;
|
|
SharedDtor();
|
|
_internal_metadata_.Delete<std::string>();
|
|
}
|
|
|
|
inline void MultiplexFrame::SharedDtor() {
|
|
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
|
|
if (this != internal_default_instance()) delete header_;
|
|
if (has_Frame()) {
|
|
clear_Frame();
|
|
}
|
|
}
|
|
|
|
void MultiplexFrame::ArenaDtor(void* object) {
|
|
MultiplexFrame* _this = reinterpret_cast< MultiplexFrame* >(object);
|
|
(void)_this;
|
|
}
|
|
void MultiplexFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
|
|
}
|
|
void MultiplexFrame::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
|
|
void MultiplexFrame::clear_Frame() {
|
|
// @@protoc_insertion_point(one_of_clear_start:location.nearby.mediums.MultiplexFrame)
|
|
switch (Frame_case()) {
|
|
case kControlFrame: {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete Frame_.control_frame_;
|
|
}
|
|
break;
|
|
}
|
|
case kDataFrame: {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete Frame_.data_frame_;
|
|
}
|
|
break;
|
|
}
|
|
case FRAME_NOT_SET: {
|
|
break;
|
|
}
|
|
}
|
|
_oneof_case_[0] = FRAME_NOT_SET;
|
|
}
|
|
|
|
|
|
void MultiplexFrame::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.MultiplexFrame)
|
|
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) {
|
|
GOOGLE_DCHECK(header_ != nullptr);
|
|
header_->Clear();
|
|
}
|
|
frame_type_ = 0;
|
|
clear_Frame();
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear<std::string>();
|
|
}
|
|
|
|
const char* MultiplexFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
uint32_t tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
switch (tag >> 3) {
|
|
// optional .location.nearby.mediums.MultiplexFrameHeader header = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_header(), ptr);
|
|
CHK_(ptr);
|
|
} else
|
|
goto handle_unusual;
|
|
continue;
|
|
// optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_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(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType_IsValid(val))) {
|
|
_internal_set_frame_type(static_cast<::location::nearby::mediums::MultiplexFrame_MultiplexFrameType>(val));
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
|
|
}
|
|
} else
|
|
goto handle_unusual;
|
|
continue;
|
|
// .location.nearby.mediums.MultiplexControlFrame control_frame = 3;
|
|
case 3:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_control_frame(), ptr);
|
|
CHK_(ptr);
|
|
} else
|
|
goto handle_unusual;
|
|
continue;
|
|
// .location.nearby.mediums.MultiplexDataFrame data_frame = 4;
|
|
case 4:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_data_frame(), 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* MultiplexFrame::_InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.MultiplexFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .location.nearby.mediums.MultiplexFrameHeader header = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
1, _Internal::header(this), target, stream);
|
|
}
|
|
|
|
// optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_type = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
|
|
2, this->_internal_frame_type(), target);
|
|
}
|
|
|
|
switch (Frame_case()) {
|
|
case kControlFrame: {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
3, _Internal::control_frame(this), target, stream);
|
|
break;
|
|
}
|
|
case kDataFrame: {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
4, _Internal::data_frame(this), target, stream);
|
|
break;
|
|
}
|
|
default: ;
|
|
}
|
|
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.MultiplexFrame)
|
|
return target;
|
|
}
|
|
|
|
size_t MultiplexFrame::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.MultiplexFrame)
|
|
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 .location.nearby.mediums.MultiplexFrameHeader header = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*header_);
|
|
}
|
|
|
|
// optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_type = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_frame_type());
|
|
}
|
|
|
|
}
|
|
switch (Frame_case()) {
|
|
// .location.nearby.mediums.MultiplexControlFrame control_frame = 3;
|
|
case kControlFrame: {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*Frame_.control_frame_);
|
|
break;
|
|
}
|
|
// .location.nearby.mediums.MultiplexDataFrame data_frame = 4;
|
|
case kDataFrame: {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*Frame_.data_frame_);
|
|
break;
|
|
}
|
|
case FRAME_NOT_SET: {
|
|
break;
|
|
}
|
|
}
|
|
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 MultiplexFrame::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MultiplexFrame*>(
|
|
&from));
|
|
}
|
|
|
|
void MultiplexFrame::MergeFrom(const MultiplexFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.MultiplexFrame)
|
|
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_mutable_header()->::location::nearby::mediums::MultiplexFrameHeader::MergeFrom(from._internal_header());
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
frame_type_ = from.frame_type_;
|
|
}
|
|
_has_bits_[0] |= cached_has_bits;
|
|
}
|
|
switch (from.Frame_case()) {
|
|
case kControlFrame: {
|
|
_internal_mutable_control_frame()->::location::nearby::mediums::MultiplexControlFrame::MergeFrom(from._internal_control_frame());
|
|
break;
|
|
}
|
|
case kDataFrame: {
|
|
_internal_mutable_data_frame()->::location::nearby::mediums::MultiplexDataFrame::MergeFrom(from._internal_data_frame());
|
|
break;
|
|
}
|
|
case FRAME_NOT_SET: {
|
|
break;
|
|
}
|
|
}
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
}
|
|
|
|
void MultiplexFrame::CopyFrom(const MultiplexFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.MultiplexFrame)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool MultiplexFrame::IsInitialized() const {
|
|
return true;
|
|
}
|
|
|
|
void MultiplexFrame::InternalSwap(MultiplexFrame* other) {
|
|
using std::swap;
|
|
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
::PROTOBUF_NAMESPACE_ID::internal::memswap<
|
|
PROTOBUF_FIELD_OFFSET(MultiplexFrame, frame_type_)
|
|
+ sizeof(MultiplexFrame::frame_type_)
|
|
- PROTOBUF_FIELD_OFFSET(MultiplexFrame, header_)>(
|
|
reinterpret_cast<char*>(&header_),
|
|
reinterpret_cast<char*>(&other->header_));
|
|
swap(Frame_, other->Frame_);
|
|
swap(_oneof_case_[0], other->_oneof_case_[0]);
|
|
}
|
|
|
|
std::string MultiplexFrame::GetTypeName() const {
|
|
return "location.nearby.mediums.MultiplexFrame";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
class MultiplexFrameHeader::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<MultiplexFrameHeader>()._has_bits_);
|
|
static void set_has_salted_service_id_hash(HasBits* has_bits) {
|
|
(*has_bits)[0] |= 1u;
|
|
}
|
|
static void set_has_service_id_hash_salt(HasBits* has_bits) {
|
|
(*has_bits)[0] |= 2u;
|
|
}
|
|
};
|
|
|
|
MultiplexFrameHeader::MultiplexFrameHeader(::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.MultiplexFrameHeader)
|
|
}
|
|
MultiplexFrameHeader::MultiplexFrameHeader(const MultiplexFrameHeader& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
salted_service_id_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
salted_service_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (from._internal_has_salted_service_id_hash()) {
|
|
salted_service_id_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_salted_service_id_hash(),
|
|
GetArenaForAllocation());
|
|
}
|
|
service_id_hash_salt_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (from._internal_has_service_id_hash_salt()) {
|
|
service_id_hash_salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_service_id_hash_salt(),
|
|
GetArenaForAllocation());
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:location.nearby.mediums.MultiplexFrameHeader)
|
|
}
|
|
|
|
inline void MultiplexFrameHeader::SharedCtor() {
|
|
salted_service_id_hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
salted_service_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
service_id_hash_salt_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
}
|
|
|
|
MultiplexFrameHeader::~MultiplexFrameHeader() {
|
|
// @@protoc_insertion_point(destructor:location.nearby.mediums.MultiplexFrameHeader)
|
|
if (GetArenaForAllocation() != nullptr) return;
|
|
SharedDtor();
|
|
_internal_metadata_.Delete<std::string>();
|
|
}
|
|
|
|
inline void MultiplexFrameHeader::SharedDtor() {
|
|
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
|
|
salted_service_id_hash_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
service_id_hash_salt_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void MultiplexFrameHeader::ArenaDtor(void* object) {
|
|
MultiplexFrameHeader* _this = reinterpret_cast< MultiplexFrameHeader* >(object);
|
|
(void)_this;
|
|
}
|
|
void MultiplexFrameHeader::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
|
|
}
|
|
void MultiplexFrameHeader::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
|
|
void MultiplexFrameHeader::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.MultiplexFrameHeader)
|
|
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) {
|
|
salted_service_id_hash_.ClearNonDefaultToEmpty();
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
service_id_hash_salt_.ClearNonDefaultToEmpty();
|
|
}
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear<std::string>();
|
|
}
|
|
|
|
const char* MultiplexFrameHeader::_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 salted_service_id_hash = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
|
|
auto str = _internal_mutable_salted_service_id_hash();
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
|
|
CHK_(ptr);
|
|
} else
|
|
goto handle_unusual;
|
|
continue;
|
|
// optional string service_id_hash_salt = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
|
|
auto str = _internal_mutable_service_id_hash_salt();
|
|
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* MultiplexFrameHeader::_InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.MultiplexFrameHeader)
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional bytes salted_service_id_hash = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->WriteBytesMaybeAliased(
|
|
1, this->_internal_salted_service_id_hash(), target);
|
|
}
|
|
|
|
// optional string service_id_hash_salt = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
target = stream->WriteStringMaybeAliased(
|
|
2, this->_internal_service_id_hash_salt(), 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.MultiplexFrameHeader)
|
|
return target;
|
|
}
|
|
|
|
size_t MultiplexFrameHeader::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.MultiplexFrameHeader)
|
|
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 salted_service_id_hash = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
|
|
this->_internal_salted_service_id_hash());
|
|
}
|
|
|
|
// optional string service_id_hash_salt = 2;
|
|
if (cached_has_bits & 0x00000002u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
|
|
this->_internal_service_id_hash_salt());
|
|
}
|
|
|
|
}
|
|
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 MultiplexFrameHeader::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MultiplexFrameHeader*>(
|
|
&from));
|
|
}
|
|
|
|
void MultiplexFrameHeader::MergeFrom(const MultiplexFrameHeader& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.MultiplexFrameHeader)
|
|
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_salted_service_id_hash(from._internal_salted_service_id_hash());
|
|
}
|
|
if (cached_has_bits & 0x00000002u) {
|
|
_internal_set_service_id_hash_salt(from._internal_service_id_hash_salt());
|
|
}
|
|
}
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
}
|
|
|
|
void MultiplexFrameHeader::CopyFrom(const MultiplexFrameHeader& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.MultiplexFrameHeader)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool MultiplexFrameHeader::IsInitialized() const {
|
|
return true;
|
|
}
|
|
|
|
void MultiplexFrameHeader::InternalSwap(MultiplexFrameHeader* 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(),
|
|
&salted_service_id_hash_, lhs_arena,
|
|
&other->salted_service_id_hash_, rhs_arena
|
|
);
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
|
|
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
&service_id_hash_salt_, lhs_arena,
|
|
&other->service_id_hash_salt_, rhs_arena
|
|
);
|
|
}
|
|
|
|
std::string MultiplexFrameHeader::GetTypeName() const {
|
|
return "location.nearby.mediums.MultiplexFrameHeader";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
class MultiplexControlFrame::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<MultiplexControlFrame>()._has_bits_);
|
|
static void set_has_control_frame_type(HasBits* has_bits) {
|
|
(*has_bits)[0] |= 1u;
|
|
}
|
|
static const ::location::nearby::mediums::ConnectionRequestFrame& connection_request_frame(const MultiplexControlFrame* msg);
|
|
static const ::location::nearby::mediums::ConnectionResponseFrame& connection_response_frame(const MultiplexControlFrame* msg);
|
|
static const ::location::nearby::mediums::DisconnectFrame& disconnect_frame(const MultiplexControlFrame* msg);
|
|
};
|
|
|
|
const ::location::nearby::mediums::ConnectionRequestFrame&
|
|
MultiplexControlFrame::_Internal::connection_request_frame(const MultiplexControlFrame* msg) {
|
|
return *msg->Frame_.connection_request_frame_;
|
|
}
|
|
const ::location::nearby::mediums::ConnectionResponseFrame&
|
|
MultiplexControlFrame::_Internal::connection_response_frame(const MultiplexControlFrame* msg) {
|
|
return *msg->Frame_.connection_response_frame_;
|
|
}
|
|
const ::location::nearby::mediums::DisconnectFrame&
|
|
MultiplexControlFrame::_Internal::disconnect_frame(const MultiplexControlFrame* msg) {
|
|
return *msg->Frame_.disconnect_frame_;
|
|
}
|
|
void MultiplexControlFrame::set_allocated_connection_request_frame(::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
clear_Frame();
|
|
if (connection_request_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::ConnectionRequestFrame>::GetOwningArena(connection_request_frame);
|
|
if (message_arena != submessage_arena) {
|
|
connection_request_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, connection_request_frame, submessage_arena);
|
|
}
|
|
set_has_connection_request_frame();
|
|
Frame_.connection_request_frame_ = connection_request_frame;
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
|
|
}
|
|
void MultiplexControlFrame::set_allocated_connection_response_frame(::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
clear_Frame();
|
|
if (connection_response_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::ConnectionResponseFrame>::GetOwningArena(connection_response_frame);
|
|
if (message_arena != submessage_arena) {
|
|
connection_response_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, connection_response_frame, submessage_arena);
|
|
}
|
|
set_has_connection_response_frame();
|
|
Frame_.connection_response_frame_ = connection_response_frame;
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
|
|
}
|
|
void MultiplexControlFrame::set_allocated_disconnect_frame(::location::nearby::mediums::DisconnectFrame* disconnect_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
clear_Frame();
|
|
if (disconnect_frame) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::DisconnectFrame>::GetOwningArena(disconnect_frame);
|
|
if (message_arena != submessage_arena) {
|
|
disconnect_frame = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, disconnect_frame, submessage_arena);
|
|
}
|
|
set_has_disconnect_frame();
|
|
Frame_.disconnect_frame_ = disconnect_frame;
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
|
|
}
|
|
MultiplexControlFrame::MultiplexControlFrame(::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.MultiplexControlFrame)
|
|
}
|
|
MultiplexControlFrame::MultiplexControlFrame(const MultiplexControlFrame& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
control_frame_type_ = from.control_frame_type_;
|
|
clear_has_Frame();
|
|
switch (from.Frame_case()) {
|
|
case kConnectionRequestFrame: {
|
|
_internal_mutable_connection_request_frame()->::location::nearby::mediums::ConnectionRequestFrame::MergeFrom(from._internal_connection_request_frame());
|
|
break;
|
|
}
|
|
case kConnectionResponseFrame: {
|
|
_internal_mutable_connection_response_frame()->::location::nearby::mediums::ConnectionResponseFrame::MergeFrom(from._internal_connection_response_frame());
|
|
break;
|
|
}
|
|
case kDisconnectFrame: {
|
|
_internal_mutable_disconnect_frame()->::location::nearby::mediums::DisconnectFrame::MergeFrom(from._internal_disconnect_frame());
|
|
break;
|
|
}
|
|
case FRAME_NOT_SET: {
|
|
break;
|
|
}
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:location.nearby.mediums.MultiplexControlFrame)
|
|
}
|
|
|
|
inline void MultiplexControlFrame::SharedCtor() {
|
|
control_frame_type_ = 0;
|
|
clear_has_Frame();
|
|
}
|
|
|
|
MultiplexControlFrame::~MultiplexControlFrame() {
|
|
// @@protoc_insertion_point(destructor:location.nearby.mediums.MultiplexControlFrame)
|
|
if (GetArenaForAllocation() != nullptr) return;
|
|
SharedDtor();
|
|
_internal_metadata_.Delete<std::string>();
|
|
}
|
|
|
|
inline void MultiplexControlFrame::SharedDtor() {
|
|
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
|
|
if (has_Frame()) {
|
|
clear_Frame();
|
|
}
|
|
}
|
|
|
|
void MultiplexControlFrame::ArenaDtor(void* object) {
|
|
MultiplexControlFrame* _this = reinterpret_cast< MultiplexControlFrame* >(object);
|
|
(void)_this;
|
|
}
|
|
void MultiplexControlFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
|
|
}
|
|
void MultiplexControlFrame::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
|
|
void MultiplexControlFrame::clear_Frame() {
|
|
// @@protoc_insertion_point(one_of_clear_start:location.nearby.mediums.MultiplexControlFrame)
|
|
switch (Frame_case()) {
|
|
case kConnectionRequestFrame: {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete Frame_.connection_request_frame_;
|
|
}
|
|
break;
|
|
}
|
|
case kConnectionResponseFrame: {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete Frame_.connection_response_frame_;
|
|
}
|
|
break;
|
|
}
|
|
case kDisconnectFrame: {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete Frame_.disconnect_frame_;
|
|
}
|
|
break;
|
|
}
|
|
case FRAME_NOT_SET: {
|
|
break;
|
|
}
|
|
}
|
|
_oneof_case_[0] = FRAME_NOT_SET;
|
|
}
|
|
|
|
|
|
void MultiplexControlFrame::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.MultiplexControlFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
control_frame_type_ = 0;
|
|
clear_Frame();
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear<std::string>();
|
|
}
|
|
|
|
const char* MultiplexControlFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
uint32_t tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
switch (tag >> 3) {
|
|
// optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
|
|
uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
|
|
CHK_(ptr);
|
|
if (PROTOBUF_PREDICT_TRUE(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType_IsValid(val))) {
|
|
_internal_set_control_frame_type(static_cast<::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType>(val));
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
|
|
}
|
|
} else
|
|
goto handle_unusual;
|
|
continue;
|
|
// .location.nearby.mediums.ConnectionRequestFrame connection_request_frame = 2;
|
|
case 2:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_connection_request_frame(), ptr);
|
|
CHK_(ptr);
|
|
} else
|
|
goto handle_unusual;
|
|
continue;
|
|
// .location.nearby.mediums.ConnectionResponseFrame connection_response_frame = 3;
|
|
case 3:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_connection_response_frame(), ptr);
|
|
CHK_(ptr);
|
|
} else
|
|
goto handle_unusual;
|
|
continue;
|
|
// .location.nearby.mediums.DisconnectFrame disconnect_frame = 4;
|
|
case 4:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
|
|
ptr = ctx->ParseMessage(_internal_mutable_disconnect_frame(), 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* MultiplexControlFrame::_InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.MultiplexControlFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
|
|
1, this->_internal_control_frame_type(), target);
|
|
}
|
|
|
|
switch (Frame_case()) {
|
|
case kConnectionRequestFrame: {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
2, _Internal::connection_request_frame(this), target, stream);
|
|
break;
|
|
}
|
|
case kConnectionResponseFrame: {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
3, _Internal::connection_response_frame(this), target, stream);
|
|
break;
|
|
}
|
|
case kDisconnectFrame: {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
|
|
InternalWriteMessage(
|
|
4, _Internal::disconnect_frame(this), target, stream);
|
|
break;
|
|
}
|
|
default: ;
|
|
}
|
|
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.MultiplexControlFrame)
|
|
return target;
|
|
}
|
|
|
|
size_t MultiplexControlFrame::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.MultiplexControlFrame)
|
|
size_t total_size = 0;
|
|
|
|
uint32_t cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
// optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_control_frame_type());
|
|
}
|
|
|
|
switch (Frame_case()) {
|
|
// .location.nearby.mediums.ConnectionRequestFrame connection_request_frame = 2;
|
|
case kConnectionRequestFrame: {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*Frame_.connection_request_frame_);
|
|
break;
|
|
}
|
|
// .location.nearby.mediums.ConnectionResponseFrame connection_response_frame = 3;
|
|
case kConnectionResponseFrame: {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*Frame_.connection_response_frame_);
|
|
break;
|
|
}
|
|
// .location.nearby.mediums.DisconnectFrame disconnect_frame = 4;
|
|
case kDisconnectFrame: {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
|
|
*Frame_.disconnect_frame_);
|
|
break;
|
|
}
|
|
case FRAME_NOT_SET: {
|
|
break;
|
|
}
|
|
}
|
|
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 MultiplexControlFrame::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MultiplexControlFrame*>(
|
|
&from));
|
|
}
|
|
|
|
void MultiplexControlFrame::MergeFrom(const MultiplexControlFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.MultiplexControlFrame)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
if (from._internal_has_control_frame_type()) {
|
|
_internal_set_control_frame_type(from._internal_control_frame_type());
|
|
}
|
|
switch (from.Frame_case()) {
|
|
case kConnectionRequestFrame: {
|
|
_internal_mutable_connection_request_frame()->::location::nearby::mediums::ConnectionRequestFrame::MergeFrom(from._internal_connection_request_frame());
|
|
break;
|
|
}
|
|
case kConnectionResponseFrame: {
|
|
_internal_mutable_connection_response_frame()->::location::nearby::mediums::ConnectionResponseFrame::MergeFrom(from._internal_connection_response_frame());
|
|
break;
|
|
}
|
|
case kDisconnectFrame: {
|
|
_internal_mutable_disconnect_frame()->::location::nearby::mediums::DisconnectFrame::MergeFrom(from._internal_disconnect_frame());
|
|
break;
|
|
}
|
|
case FRAME_NOT_SET: {
|
|
break;
|
|
}
|
|
}
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
}
|
|
|
|
void MultiplexControlFrame::CopyFrom(const MultiplexControlFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.MultiplexControlFrame)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool MultiplexControlFrame::IsInitialized() const {
|
|
return true;
|
|
}
|
|
|
|
void MultiplexControlFrame::InternalSwap(MultiplexControlFrame* other) {
|
|
using std::swap;
|
|
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
swap(control_frame_type_, other->control_frame_type_);
|
|
swap(Frame_, other->Frame_);
|
|
swap(_oneof_case_[0], other->_oneof_case_[0]);
|
|
}
|
|
|
|
std::string MultiplexControlFrame::GetTypeName() const {
|
|
return "location.nearby.mediums.MultiplexControlFrame";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
class ConnectionRequestFrame::_Internal {
|
|
public:
|
|
};
|
|
|
|
ConnectionRequestFrame::ConnectionRequestFrame(::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.ConnectionRequestFrame)
|
|
}
|
|
ConnectionRequestFrame::ConnectionRequestFrame(const ConnectionRequestFrame& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite() {
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
// @@protoc_insertion_point(copy_constructor:location.nearby.mediums.ConnectionRequestFrame)
|
|
}
|
|
|
|
inline void ConnectionRequestFrame::SharedCtor() {
|
|
}
|
|
|
|
ConnectionRequestFrame::~ConnectionRequestFrame() {
|
|
// @@protoc_insertion_point(destructor:location.nearby.mediums.ConnectionRequestFrame)
|
|
if (GetArenaForAllocation() != nullptr) return;
|
|
SharedDtor();
|
|
_internal_metadata_.Delete<std::string>();
|
|
}
|
|
|
|
inline void ConnectionRequestFrame::SharedDtor() {
|
|
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
|
|
}
|
|
|
|
void ConnectionRequestFrame::ArenaDtor(void* object) {
|
|
ConnectionRequestFrame* _this = reinterpret_cast< ConnectionRequestFrame* >(object);
|
|
(void)_this;
|
|
}
|
|
void ConnectionRequestFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
|
|
}
|
|
void ConnectionRequestFrame::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
|
|
void ConnectionRequestFrame::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.ConnectionRequestFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
_internal_metadata_.Clear<std::string>();
|
|
}
|
|
|
|
const char* ConnectionRequestFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
while (!ctx->Done(&ptr)) {
|
|
uint32_t tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
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:
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto message_done;
|
|
#undef CHK_
|
|
}
|
|
|
|
uint8_t* ConnectionRequestFrame::_InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.ConnectionRequestFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
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.ConnectionRequestFrame)
|
|
return target;
|
|
}
|
|
|
|
size_t ConnectionRequestFrame::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.ConnectionRequestFrame)
|
|
size_t total_size = 0;
|
|
|
|
uint32_t cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
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 ConnectionRequestFrame::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ConnectionRequestFrame*>(
|
|
&from));
|
|
}
|
|
|
|
void ConnectionRequestFrame::MergeFrom(const ConnectionRequestFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.ConnectionRequestFrame)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
}
|
|
|
|
void ConnectionRequestFrame::CopyFrom(const ConnectionRequestFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.ConnectionRequestFrame)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool ConnectionRequestFrame::IsInitialized() const {
|
|
return true;
|
|
}
|
|
|
|
void ConnectionRequestFrame::InternalSwap(ConnectionRequestFrame* other) {
|
|
using std::swap;
|
|
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
|
|
}
|
|
|
|
std::string ConnectionRequestFrame::GetTypeName() const {
|
|
return "location.nearby.mediums.ConnectionRequestFrame";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
class ConnectionResponseFrame::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<ConnectionResponseFrame>()._has_bits_);
|
|
static void set_has_connection_response_code(HasBits* has_bits) {
|
|
(*has_bits)[0] |= 1u;
|
|
}
|
|
};
|
|
|
|
ConnectionResponseFrame::ConnectionResponseFrame(::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.ConnectionResponseFrame)
|
|
}
|
|
ConnectionResponseFrame::ConnectionResponseFrame(const ConnectionResponseFrame& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
connection_response_code_ = from.connection_response_code_;
|
|
// @@protoc_insertion_point(copy_constructor:location.nearby.mediums.ConnectionResponseFrame)
|
|
}
|
|
|
|
inline void ConnectionResponseFrame::SharedCtor() {
|
|
connection_response_code_ = 0;
|
|
}
|
|
|
|
ConnectionResponseFrame::~ConnectionResponseFrame() {
|
|
// @@protoc_insertion_point(destructor:location.nearby.mediums.ConnectionResponseFrame)
|
|
if (GetArenaForAllocation() != nullptr) return;
|
|
SharedDtor();
|
|
_internal_metadata_.Delete<std::string>();
|
|
}
|
|
|
|
inline void ConnectionResponseFrame::SharedDtor() {
|
|
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
|
|
}
|
|
|
|
void ConnectionResponseFrame::ArenaDtor(void* object) {
|
|
ConnectionResponseFrame* _this = reinterpret_cast< ConnectionResponseFrame* >(object);
|
|
(void)_this;
|
|
}
|
|
void ConnectionResponseFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
|
|
}
|
|
void ConnectionResponseFrame::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
|
|
void ConnectionResponseFrame::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.ConnectionResponseFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
connection_response_code_ = 0;
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear<std::string>();
|
|
}
|
|
|
|
const char* ConnectionResponseFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
_Internal::HasBits has_bits{};
|
|
while (!ctx->Done(&ptr)) {
|
|
uint32_t tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
switch (tag >> 3) {
|
|
// optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
|
|
uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
|
|
CHK_(ptr);
|
|
if (PROTOBUF_PREDICT_TRUE(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode_IsValid(val))) {
|
|
_internal_set_connection_response_code(static_cast<::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode>(val));
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
|
|
}
|
|
} else
|
|
goto handle_unusual;
|
|
continue;
|
|
default:
|
|
goto handle_unusual;
|
|
} // switch
|
|
handle_unusual:
|
|
if ((tag == 0) || ((tag & 7) == 4)) {
|
|
CHK_(ptr);
|
|
ctx->SetLastTag(tag);
|
|
goto message_done;
|
|
}
|
|
ptr = UnknownFieldParse(
|
|
tag,
|
|
_internal_metadata_.mutable_unknown_fields<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* ConnectionResponseFrame::_InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.ConnectionResponseFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->EnsureSpace(target);
|
|
target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
|
|
1, this->_internal_connection_response_code(), 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.ConnectionResponseFrame)
|
|
return target;
|
|
}
|
|
|
|
size_t ConnectionResponseFrame::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.ConnectionResponseFrame)
|
|
size_t total_size = 0;
|
|
|
|
uint32_t cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
// optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_connection_response_code());
|
|
}
|
|
|
|
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 ConnectionResponseFrame::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const ConnectionResponseFrame*>(
|
|
&from));
|
|
}
|
|
|
|
void ConnectionResponseFrame::MergeFrom(const ConnectionResponseFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.ConnectionResponseFrame)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
if (from._internal_has_connection_response_code()) {
|
|
_internal_set_connection_response_code(from._internal_connection_response_code());
|
|
}
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
}
|
|
|
|
void ConnectionResponseFrame::CopyFrom(const ConnectionResponseFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.ConnectionResponseFrame)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool ConnectionResponseFrame::IsInitialized() const {
|
|
return true;
|
|
}
|
|
|
|
void ConnectionResponseFrame::InternalSwap(ConnectionResponseFrame* other) {
|
|
using std::swap;
|
|
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
|
|
swap(_has_bits_[0], other->_has_bits_[0]);
|
|
swap(connection_response_code_, other->connection_response_code_);
|
|
}
|
|
|
|
std::string ConnectionResponseFrame::GetTypeName() const {
|
|
return "location.nearby.mediums.ConnectionResponseFrame";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
class DisconnectFrame::_Internal {
|
|
public:
|
|
};
|
|
|
|
DisconnectFrame::DisconnectFrame(::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.DisconnectFrame)
|
|
}
|
|
DisconnectFrame::DisconnectFrame(const DisconnectFrame& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite() {
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
// @@protoc_insertion_point(copy_constructor:location.nearby.mediums.DisconnectFrame)
|
|
}
|
|
|
|
inline void DisconnectFrame::SharedCtor() {
|
|
}
|
|
|
|
DisconnectFrame::~DisconnectFrame() {
|
|
// @@protoc_insertion_point(destructor:location.nearby.mediums.DisconnectFrame)
|
|
if (GetArenaForAllocation() != nullptr) return;
|
|
SharedDtor();
|
|
_internal_metadata_.Delete<std::string>();
|
|
}
|
|
|
|
inline void DisconnectFrame::SharedDtor() {
|
|
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
|
|
}
|
|
|
|
void DisconnectFrame::ArenaDtor(void* object) {
|
|
DisconnectFrame* _this = reinterpret_cast< DisconnectFrame* >(object);
|
|
(void)_this;
|
|
}
|
|
void DisconnectFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
|
|
}
|
|
void DisconnectFrame::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
|
|
void DisconnectFrame::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.DisconnectFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
_internal_metadata_.Clear<std::string>();
|
|
}
|
|
|
|
const char* DisconnectFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
|
|
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
|
|
while (!ctx->Done(&ptr)) {
|
|
uint32_t tag;
|
|
ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
|
|
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:
|
|
return ptr;
|
|
failure:
|
|
ptr = nullptr;
|
|
goto message_done;
|
|
#undef CHK_
|
|
}
|
|
|
|
uint8_t* DisconnectFrame::_InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.DisconnectFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
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.DisconnectFrame)
|
|
return target;
|
|
}
|
|
|
|
size_t DisconnectFrame::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.DisconnectFrame)
|
|
size_t total_size = 0;
|
|
|
|
uint32_t cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
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 DisconnectFrame::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const DisconnectFrame*>(
|
|
&from));
|
|
}
|
|
|
|
void DisconnectFrame::MergeFrom(const DisconnectFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.DisconnectFrame)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
}
|
|
|
|
void DisconnectFrame::CopyFrom(const DisconnectFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.DisconnectFrame)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool DisconnectFrame::IsInitialized() const {
|
|
return true;
|
|
}
|
|
|
|
void DisconnectFrame::InternalSwap(DisconnectFrame* other) {
|
|
using std::swap;
|
|
_internal_metadata_.InternalSwap(&other->_internal_metadata_);
|
|
}
|
|
|
|
std::string DisconnectFrame::GetTypeName() const {
|
|
return "location.nearby.mediums.DisconnectFrame";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
class MultiplexDataFrame::_Internal {
|
|
public:
|
|
using HasBits = decltype(std::declval<MultiplexDataFrame>()._has_bits_);
|
|
static void set_has_data(HasBits* has_bits) {
|
|
(*has_bits)[0] |= 1u;
|
|
}
|
|
};
|
|
|
|
MultiplexDataFrame::MultiplexDataFrame(::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.MultiplexDataFrame)
|
|
}
|
|
MultiplexDataFrame::MultiplexDataFrame(const MultiplexDataFrame& from)
|
|
: ::PROTOBUF_NAMESPACE_ID::MessageLite(),
|
|
_has_bits_(from._has_bits_) {
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
if (from._internal_has_data()) {
|
|
data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_data(),
|
|
GetArenaForAllocation());
|
|
}
|
|
// @@protoc_insertion_point(copy_constructor:location.nearby.mediums.MultiplexDataFrame)
|
|
}
|
|
|
|
inline void MultiplexDataFrame::SharedCtor() {
|
|
data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
|
|
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
|
|
}
|
|
|
|
MultiplexDataFrame::~MultiplexDataFrame() {
|
|
// @@protoc_insertion_point(destructor:location.nearby.mediums.MultiplexDataFrame)
|
|
if (GetArenaForAllocation() != nullptr) return;
|
|
SharedDtor();
|
|
_internal_metadata_.Delete<std::string>();
|
|
}
|
|
|
|
inline void MultiplexDataFrame::SharedDtor() {
|
|
GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
|
|
data_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
|
|
void MultiplexDataFrame::ArenaDtor(void* object) {
|
|
MultiplexDataFrame* _this = reinterpret_cast< MultiplexDataFrame* >(object);
|
|
(void)_this;
|
|
}
|
|
void MultiplexDataFrame::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
|
|
}
|
|
void MultiplexDataFrame::SetCachedSize(int size) const {
|
|
_cached_size_.Set(size);
|
|
}
|
|
|
|
void MultiplexDataFrame::Clear() {
|
|
// @@protoc_insertion_point(message_clear_start:location.nearby.mediums.MultiplexDataFrame)
|
|
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) {
|
|
data_.ClearNonDefaultToEmpty();
|
|
}
|
|
_has_bits_.Clear();
|
|
_internal_metadata_.Clear<std::string>();
|
|
}
|
|
|
|
const char* MultiplexDataFrame::_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 data = 1;
|
|
case 1:
|
|
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
|
|
auto str = _internal_mutable_data();
|
|
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* MultiplexDataFrame::_InternalSerialize(
|
|
uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
|
|
// @@protoc_insertion_point(serialize_to_array_start:location.nearby.mediums.MultiplexDataFrame)
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
cached_has_bits = _has_bits_[0];
|
|
// optional bytes data = 1;
|
|
if (cached_has_bits & 0x00000001u) {
|
|
target = stream->WriteBytesMaybeAliased(
|
|
1, this->_internal_data(), 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.MultiplexDataFrame)
|
|
return target;
|
|
}
|
|
|
|
size_t MultiplexDataFrame::ByteSizeLong() const {
|
|
// @@protoc_insertion_point(message_byte_size_start:location.nearby.mediums.MultiplexDataFrame)
|
|
size_t total_size = 0;
|
|
|
|
uint32_t cached_has_bits = 0;
|
|
// Prevent compiler warnings about cached_has_bits being unused
|
|
(void) cached_has_bits;
|
|
|
|
// optional bytes data = 1;
|
|
cached_has_bits = _has_bits_[0];
|
|
if (cached_has_bits & 0x00000001u) {
|
|
total_size += 1 +
|
|
::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
|
|
this->_internal_data());
|
|
}
|
|
|
|
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 MultiplexDataFrame::CheckTypeAndMergeFrom(
|
|
const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
|
|
MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const MultiplexDataFrame*>(
|
|
&from));
|
|
}
|
|
|
|
void MultiplexDataFrame::MergeFrom(const MultiplexDataFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_merge_from_start:location.nearby.mediums.MultiplexDataFrame)
|
|
GOOGLE_DCHECK_NE(&from, this);
|
|
uint32_t cached_has_bits = 0;
|
|
(void) cached_has_bits;
|
|
|
|
if (from._internal_has_data()) {
|
|
_internal_set_data(from._internal_data());
|
|
}
|
|
_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
|
|
}
|
|
|
|
void MultiplexDataFrame::CopyFrom(const MultiplexDataFrame& from) {
|
|
// @@protoc_insertion_point(class_specific_copy_from_start:location.nearby.mediums.MultiplexDataFrame)
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool MultiplexDataFrame::IsInitialized() const {
|
|
return true;
|
|
}
|
|
|
|
void MultiplexDataFrame::InternalSwap(MultiplexDataFrame* 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(),
|
|
&data_, lhs_arena,
|
|
&other->data_, rhs_arena
|
|
);
|
|
}
|
|
|
|
std::string MultiplexDataFrame::GetTypeName() const {
|
|
return "location.nearby.mediums.MultiplexDataFrame";
|
|
}
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
} // namespace mediums
|
|
} // namespace nearby
|
|
} // namespace location
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> PROTOBUF_NOINLINE ::location::nearby::mediums::MultiplexFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::MultiplexFrame >(Arena* arena) {
|
|
return Arena::CreateMessageInternal< ::location::nearby::mediums::MultiplexFrame >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::location::nearby::mediums::MultiplexFrameHeader* Arena::CreateMaybeMessage< ::location::nearby::mediums::MultiplexFrameHeader >(Arena* arena) {
|
|
return Arena::CreateMessageInternal< ::location::nearby::mediums::MultiplexFrameHeader >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::location::nearby::mediums::MultiplexControlFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::MultiplexControlFrame >(Arena* arena) {
|
|
return Arena::CreateMessageInternal< ::location::nearby::mediums::MultiplexControlFrame >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::location::nearby::mediums::ConnectionRequestFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::ConnectionRequestFrame >(Arena* arena) {
|
|
return Arena::CreateMessageInternal< ::location::nearby::mediums::ConnectionRequestFrame >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::location::nearby::mediums::ConnectionResponseFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::ConnectionResponseFrame >(Arena* arena) {
|
|
return Arena::CreateMessageInternal< ::location::nearby::mediums::ConnectionResponseFrame >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::location::nearby::mediums::DisconnectFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::DisconnectFrame >(Arena* arena) {
|
|
return Arena::CreateMessageInternal< ::location::nearby::mediums::DisconnectFrame >(arena);
|
|
}
|
|
template<> PROTOBUF_NOINLINE ::location::nearby::mediums::MultiplexDataFrame* Arena::CreateMaybeMessage< ::location::nearby::mediums::MultiplexDataFrame >(Arena* arena) {
|
|
return Arena::CreateMessageInternal< ::location::nearby::mediums::MultiplexDataFrame >(arena);
|
|
}
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
#include <google/protobuf/port_undef.inc>
|