// 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>