nearby/compiled_proto/proto/mediums/multiplex_frames.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: proto/mediums/multiplex_frames.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_proto_2fmediums_2fmultiplex_5fframes_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_proto_2fmediums_2fmultiplex_5fframes_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_proto_2fmediums_2fmultiplex_5fframes_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[7]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
namespace location {
namespace nearby {
namespace mediums {
class ConnectionRequestFrame;
struct ConnectionRequestFrameDefaultTypeInternal;
extern ConnectionRequestFrameDefaultTypeInternal _ConnectionRequestFrame_default_instance_;
class ConnectionResponseFrame;
struct ConnectionResponseFrameDefaultTypeInternal;
extern ConnectionResponseFrameDefaultTypeInternal _ConnectionResponseFrame_default_instance_;
class DisconnectFrame;
struct DisconnectFrameDefaultTypeInternal;
extern DisconnectFrameDefaultTypeInternal _DisconnectFrame_default_instance_;
class MultiplexControlFrame;
struct MultiplexControlFrameDefaultTypeInternal;
extern MultiplexControlFrameDefaultTypeInternal _MultiplexControlFrame_default_instance_;
class MultiplexDataFrame;
struct MultiplexDataFrameDefaultTypeInternal;
extern MultiplexDataFrameDefaultTypeInternal _MultiplexDataFrame_default_instance_;
class MultiplexFrame;
struct MultiplexFrameDefaultTypeInternal;
extern MultiplexFrameDefaultTypeInternal _MultiplexFrame_default_instance_;
class MultiplexFrameHeader;
struct MultiplexFrameHeaderDefaultTypeInternal;
extern MultiplexFrameHeaderDefaultTypeInternal _MultiplexFrameHeader_default_instance_;
}  // namespace mediums
}  // namespace nearby
}  // namespace location
PROTOBUF_NAMESPACE_OPEN
template<> ::location::nearby::mediums::ConnectionRequestFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::ConnectionRequestFrame>(Arena*);
template<> ::location::nearby::mediums::ConnectionResponseFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::ConnectionResponseFrame>(Arena*);
template<> ::location::nearby::mediums::DisconnectFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::DisconnectFrame>(Arena*);
template<> ::location::nearby::mediums::MultiplexControlFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::MultiplexControlFrame>(Arena*);
template<> ::location::nearby::mediums::MultiplexDataFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::MultiplexDataFrame>(Arena*);
template<> ::location::nearby::mediums::MultiplexFrame* Arena::CreateMaybeMessage<::location::nearby::mediums::MultiplexFrame>(Arena*);
template<> ::location::nearby::mediums::MultiplexFrameHeader* Arena::CreateMaybeMessage<::location::nearby::mediums::MultiplexFrameHeader>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace location {
namespace nearby {
namespace mediums {

enum MultiplexFrame_MultiplexFrameType : int {
  MultiplexFrame_MultiplexFrameType_UNKNOWN_FRAME_TYPE = 0,
  MultiplexFrame_MultiplexFrameType_CONTROL_FRAME = 1,
  MultiplexFrame_MultiplexFrameType_DATA_FRAME = 2
};
bool MultiplexFrame_MultiplexFrameType_IsValid(int value);
constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MIN = MultiplexFrame_MultiplexFrameType_UNKNOWN_FRAME_TYPE;
constexpr MultiplexFrame_MultiplexFrameType MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MAX = MultiplexFrame_MultiplexFrameType_DATA_FRAME;
constexpr int MultiplexFrame_MultiplexFrameType_MultiplexFrameType_ARRAYSIZE = MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MAX + 1;

const std::string& MultiplexFrame_MultiplexFrameType_Name(MultiplexFrame_MultiplexFrameType value);
template<typename T>
inline const std::string& MultiplexFrame_MultiplexFrameType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MultiplexFrame_MultiplexFrameType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MultiplexFrame_MultiplexFrameType_Name.");
  return MultiplexFrame_MultiplexFrameType_Name(static_cast<MultiplexFrame_MultiplexFrameType>(enum_t_value));
}
bool MultiplexFrame_MultiplexFrameType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiplexFrame_MultiplexFrameType* value);
enum MultiplexControlFrame_MultiplexControlFrameType : int {
  MultiplexControlFrame_MultiplexControlFrameType_UNKNOWN_CONTROL_FRAME_TYPE = 0,
  MultiplexControlFrame_MultiplexControlFrameType_CONNECTION_REQUEST = 1,
  MultiplexControlFrame_MultiplexControlFrameType_CONNECTION_RESPONSE = 2,
  MultiplexControlFrame_MultiplexControlFrameType_DISCONNECTION = 3
};
bool MultiplexControlFrame_MultiplexControlFrameType_IsValid(int value);
constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MIN = MultiplexControlFrame_MultiplexControlFrameType_UNKNOWN_CONTROL_FRAME_TYPE;
constexpr MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MAX = MultiplexControlFrame_MultiplexControlFrameType_DISCONNECTION;
constexpr int MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_ARRAYSIZE = MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MAX + 1;

const std::string& MultiplexControlFrame_MultiplexControlFrameType_Name(MultiplexControlFrame_MultiplexControlFrameType value);
template<typename T>
inline const std::string& MultiplexControlFrame_MultiplexControlFrameType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MultiplexControlFrame_MultiplexControlFrameType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MultiplexControlFrame_MultiplexControlFrameType_Name.");
  return MultiplexControlFrame_MultiplexControlFrameType_Name(static_cast<MultiplexControlFrame_MultiplexControlFrameType>(enum_t_value));
}
bool MultiplexControlFrame_MultiplexControlFrameType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MultiplexControlFrame_MultiplexControlFrameType* value);
enum ConnectionResponseFrame_ConnectionResponseCode : int {
  ConnectionResponseFrame_ConnectionResponseCode_UNKNOWN_RESPONSE_CODE = 0,
  ConnectionResponseFrame_ConnectionResponseCode_CONNECTION_ACCEPTED = 1,
  ConnectionResponseFrame_ConnectionResponseCode_NOT_LISTENING = 2
};
bool ConnectionResponseFrame_ConnectionResponseCode_IsValid(int value);
constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MIN = ConnectionResponseFrame_ConnectionResponseCode_UNKNOWN_RESPONSE_CODE;
constexpr ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MAX = ConnectionResponseFrame_ConnectionResponseCode_NOT_LISTENING;
constexpr int ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_ARRAYSIZE = ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MAX + 1;

const std::string& ConnectionResponseFrame_ConnectionResponseCode_Name(ConnectionResponseFrame_ConnectionResponseCode value);
template<typename T>
inline const std::string& ConnectionResponseFrame_ConnectionResponseCode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ConnectionResponseFrame_ConnectionResponseCode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ConnectionResponseFrame_ConnectionResponseCode_Name.");
  return ConnectionResponseFrame_ConnectionResponseCode_Name(static_cast<ConnectionResponseFrame_ConnectionResponseCode>(enum_t_value));
}
bool ConnectionResponseFrame_ConnectionResponseCode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionResponseFrame_ConnectionResponseCode* value);
// ===================================================================

class MultiplexFrame final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.MultiplexFrame) */ {
 public:
  inline MultiplexFrame() : MultiplexFrame(nullptr) {}
  ~MultiplexFrame() override;
  explicit constexpr MultiplexFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MultiplexFrame(const MultiplexFrame& from);
  MultiplexFrame(MultiplexFrame&& from) noexcept
    : MultiplexFrame() {
    *this = ::std::move(from);
  }

  inline MultiplexFrame& operator=(const MultiplexFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline MultiplexFrame& operator=(MultiplexFrame&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const MultiplexFrame& default_instance() {
    return *internal_default_instance();
  }
  enum FrameCase {
    kControlFrame = 3,
    kDataFrame = 4,
    FRAME_NOT_SET = 0,
  };

  static inline const MultiplexFrame* internal_default_instance() {
    return reinterpret_cast<const MultiplexFrame*>(
               &_MultiplexFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(MultiplexFrame& a, MultiplexFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(MultiplexFrame* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MultiplexFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MultiplexFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MultiplexFrame>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MultiplexFrame& from);
  void MergeFrom(const MultiplexFrame& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MultiplexFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "location.nearby.mediums.MultiplexFrame";
  }
  protected:
  explicit MultiplexFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef MultiplexFrame_MultiplexFrameType MultiplexFrameType;
  static constexpr MultiplexFrameType UNKNOWN_FRAME_TYPE =
    MultiplexFrame_MultiplexFrameType_UNKNOWN_FRAME_TYPE;
  static constexpr MultiplexFrameType CONTROL_FRAME =
    MultiplexFrame_MultiplexFrameType_CONTROL_FRAME;
  static constexpr MultiplexFrameType DATA_FRAME =
    MultiplexFrame_MultiplexFrameType_DATA_FRAME;
  static inline bool MultiplexFrameType_IsValid(int value) {
    return MultiplexFrame_MultiplexFrameType_IsValid(value);
  }
  static constexpr MultiplexFrameType MultiplexFrameType_MIN =
    MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MIN;
  static constexpr MultiplexFrameType MultiplexFrameType_MAX =
    MultiplexFrame_MultiplexFrameType_MultiplexFrameType_MAX;
  static constexpr int MultiplexFrameType_ARRAYSIZE =
    MultiplexFrame_MultiplexFrameType_MultiplexFrameType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& MultiplexFrameType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MultiplexFrameType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MultiplexFrameType_Name.");
    return MultiplexFrame_MultiplexFrameType_Name(enum_t_value);
  }
  static inline bool MultiplexFrameType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MultiplexFrameType* value) {
    return MultiplexFrame_MultiplexFrameType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kHeaderFieldNumber = 1,
    kFrameTypeFieldNumber = 2,
    kControlFrameFieldNumber = 3,
    kDataFrameFieldNumber = 4,
  };
  // optional .location.nearby.mediums.MultiplexFrameHeader header = 1;
  bool has_header() const;
  private:
  bool _internal_has_header() const;
  public:
  void clear_header();
  const ::location::nearby::mediums::MultiplexFrameHeader& header() const;
  PROTOBUF_NODISCARD ::location::nearby::mediums::MultiplexFrameHeader* release_header();
  ::location::nearby::mediums::MultiplexFrameHeader* mutable_header();
  void set_allocated_header(::location::nearby::mediums::MultiplexFrameHeader* header);
  private:
  const ::location::nearby::mediums::MultiplexFrameHeader& _internal_header() const;
  ::location::nearby::mediums::MultiplexFrameHeader* _internal_mutable_header();
  public:
  void unsafe_arena_set_allocated_header(
      ::location::nearby::mediums::MultiplexFrameHeader* header);
  ::location::nearby::mediums::MultiplexFrameHeader* unsafe_arena_release_header();

  // optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_type = 2;
  bool has_frame_type() const;
  private:
  bool _internal_has_frame_type() const;
  public:
  void clear_frame_type();
  ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType frame_type() const;
  void set_frame_type(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType value);
  private:
  ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType _internal_frame_type() const;
  void _internal_set_frame_type(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType value);
  public:

  // .location.nearby.mediums.MultiplexControlFrame control_frame = 3;
  bool has_control_frame() const;
  private:
  bool _internal_has_control_frame() const;
  public:
  void clear_control_frame();
  const ::location::nearby::mediums::MultiplexControlFrame& control_frame() const;
  PROTOBUF_NODISCARD ::location::nearby::mediums::MultiplexControlFrame* release_control_frame();
  ::location::nearby::mediums::MultiplexControlFrame* mutable_control_frame();
  void set_allocated_control_frame(::location::nearby::mediums::MultiplexControlFrame* control_frame);
  private:
  const ::location::nearby::mediums::MultiplexControlFrame& _internal_control_frame() const;
  ::location::nearby::mediums::MultiplexControlFrame* _internal_mutable_control_frame();
  public:
  void unsafe_arena_set_allocated_control_frame(
      ::location::nearby::mediums::MultiplexControlFrame* control_frame);
  ::location::nearby::mediums::MultiplexControlFrame* unsafe_arena_release_control_frame();

  // .location.nearby.mediums.MultiplexDataFrame data_frame = 4;
  bool has_data_frame() const;
  private:
  bool _internal_has_data_frame() const;
  public:
  void clear_data_frame();
  const ::location::nearby::mediums::MultiplexDataFrame& data_frame() const;
  PROTOBUF_NODISCARD ::location::nearby::mediums::MultiplexDataFrame* release_data_frame();
  ::location::nearby::mediums::MultiplexDataFrame* mutable_data_frame();
  void set_allocated_data_frame(::location::nearby::mediums::MultiplexDataFrame* data_frame);
  private:
  const ::location::nearby::mediums::MultiplexDataFrame& _internal_data_frame() const;
  ::location::nearby::mediums::MultiplexDataFrame* _internal_mutable_data_frame();
  public:
  void unsafe_arena_set_allocated_data_frame(
      ::location::nearby::mediums::MultiplexDataFrame* data_frame);
  ::location::nearby::mediums::MultiplexDataFrame* unsafe_arena_release_data_frame();

  void clear_Frame();
  FrameCase Frame_case() const;
  // @@protoc_insertion_point(class_scope:location.nearby.mediums.MultiplexFrame)
 private:
  class _Internal;
  void set_has_control_frame();
  void set_has_data_frame();

  inline bool has_Frame() const;
  inline void clear_has_Frame();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::location::nearby::mediums::MultiplexFrameHeader* header_;
  int frame_type_;
  union FrameUnion {
    constexpr FrameUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::location::nearby::mediums::MultiplexControlFrame* control_frame_;
    ::location::nearby::mediums::MultiplexDataFrame* data_frame_;
  } Frame_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
};
// -------------------------------------------------------------------

class MultiplexFrameHeader final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.MultiplexFrameHeader) */ {
 public:
  inline MultiplexFrameHeader() : MultiplexFrameHeader(nullptr) {}
  ~MultiplexFrameHeader() override;
  explicit constexpr MultiplexFrameHeader(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MultiplexFrameHeader(const MultiplexFrameHeader& from);
  MultiplexFrameHeader(MultiplexFrameHeader&& from) noexcept
    : MultiplexFrameHeader() {
    *this = ::std::move(from);
  }

  inline MultiplexFrameHeader& operator=(const MultiplexFrameHeader& from) {
    CopyFrom(from);
    return *this;
  }
  inline MultiplexFrameHeader& operator=(MultiplexFrameHeader&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const MultiplexFrameHeader& default_instance() {
    return *internal_default_instance();
  }
  static inline const MultiplexFrameHeader* internal_default_instance() {
    return reinterpret_cast<const MultiplexFrameHeader*>(
               &_MultiplexFrameHeader_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(MultiplexFrameHeader& a, MultiplexFrameHeader& b) {
    a.Swap(&b);
  }
  inline void Swap(MultiplexFrameHeader* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MultiplexFrameHeader* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MultiplexFrameHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MultiplexFrameHeader>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MultiplexFrameHeader& from);
  void MergeFrom(const MultiplexFrameHeader& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MultiplexFrameHeader* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "location.nearby.mediums.MultiplexFrameHeader";
  }
  protected:
  explicit MultiplexFrameHeader(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kSaltedServiceIdHashFieldNumber = 1,
    kServiceIdHashSaltFieldNumber = 2,
  };
  // optional bytes salted_service_id_hash = 1;
  bool has_salted_service_id_hash() const;
  private:
  bool _internal_has_salted_service_id_hash() const;
  public:
  void clear_salted_service_id_hash();
  const std::string& salted_service_id_hash() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_salted_service_id_hash(ArgT0&& arg0, ArgT... args);
  std::string* mutable_salted_service_id_hash();
  PROTOBUF_NODISCARD std::string* release_salted_service_id_hash();
  void set_allocated_salted_service_id_hash(std::string* salted_service_id_hash);
  private:
  const std::string& _internal_salted_service_id_hash() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_salted_service_id_hash(const std::string& value);
  std::string* _internal_mutable_salted_service_id_hash();
  public:

  // optional string service_id_hash_salt = 2;
  bool has_service_id_hash_salt() const;
  private:
  bool _internal_has_service_id_hash_salt() const;
  public:
  void clear_service_id_hash_salt();
  const std::string& service_id_hash_salt() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_service_id_hash_salt(ArgT0&& arg0, ArgT... args);
  std::string* mutable_service_id_hash_salt();
  PROTOBUF_NODISCARD std::string* release_service_id_hash_salt();
  void set_allocated_service_id_hash_salt(std::string* service_id_hash_salt);
  private:
  const std::string& _internal_service_id_hash_salt() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id_hash_salt(const std::string& value);
  std::string* _internal_mutable_service_id_hash_salt();
  public:

  // @@protoc_insertion_point(class_scope:location.nearby.mediums.MultiplexFrameHeader)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr salted_service_id_hash_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_hash_salt_;
  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
};
// -------------------------------------------------------------------

class MultiplexControlFrame final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.MultiplexControlFrame) */ {
 public:
  inline MultiplexControlFrame() : MultiplexControlFrame(nullptr) {}
  ~MultiplexControlFrame() override;
  explicit constexpr MultiplexControlFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MultiplexControlFrame(const MultiplexControlFrame& from);
  MultiplexControlFrame(MultiplexControlFrame&& from) noexcept
    : MultiplexControlFrame() {
    *this = ::std::move(from);
  }

  inline MultiplexControlFrame& operator=(const MultiplexControlFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline MultiplexControlFrame& operator=(MultiplexControlFrame&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const MultiplexControlFrame& default_instance() {
    return *internal_default_instance();
  }
  enum FrameCase {
    kConnectionRequestFrame = 2,
    kConnectionResponseFrame = 3,
    kDisconnectFrame = 4,
    FRAME_NOT_SET = 0,
  };

  static inline const MultiplexControlFrame* internal_default_instance() {
    return reinterpret_cast<const MultiplexControlFrame*>(
               &_MultiplexControlFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(MultiplexControlFrame& a, MultiplexControlFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(MultiplexControlFrame* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MultiplexControlFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MultiplexControlFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MultiplexControlFrame>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MultiplexControlFrame& from);
  void MergeFrom(const MultiplexControlFrame& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MultiplexControlFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "location.nearby.mediums.MultiplexControlFrame";
  }
  protected:
  explicit MultiplexControlFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrameType;
  static constexpr MultiplexControlFrameType UNKNOWN_CONTROL_FRAME_TYPE =
    MultiplexControlFrame_MultiplexControlFrameType_UNKNOWN_CONTROL_FRAME_TYPE;
  static constexpr MultiplexControlFrameType CONNECTION_REQUEST =
    MultiplexControlFrame_MultiplexControlFrameType_CONNECTION_REQUEST;
  static constexpr MultiplexControlFrameType CONNECTION_RESPONSE =
    MultiplexControlFrame_MultiplexControlFrameType_CONNECTION_RESPONSE;
  static constexpr MultiplexControlFrameType DISCONNECTION =
    MultiplexControlFrame_MultiplexControlFrameType_DISCONNECTION;
  static inline bool MultiplexControlFrameType_IsValid(int value) {
    return MultiplexControlFrame_MultiplexControlFrameType_IsValid(value);
  }
  static constexpr MultiplexControlFrameType MultiplexControlFrameType_MIN =
    MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MIN;
  static constexpr MultiplexControlFrameType MultiplexControlFrameType_MAX =
    MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_MAX;
  static constexpr int MultiplexControlFrameType_ARRAYSIZE =
    MultiplexControlFrame_MultiplexControlFrameType_MultiplexControlFrameType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& MultiplexControlFrameType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MultiplexControlFrameType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MultiplexControlFrameType_Name.");
    return MultiplexControlFrame_MultiplexControlFrameType_Name(enum_t_value);
  }
  static inline bool MultiplexControlFrameType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      MultiplexControlFrameType* value) {
    return MultiplexControlFrame_MultiplexControlFrameType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kControlFrameTypeFieldNumber = 1,
    kConnectionRequestFrameFieldNumber = 2,
    kConnectionResponseFrameFieldNumber = 3,
    kDisconnectFrameFieldNumber = 4,
  };
  // optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
  bool has_control_frame_type() const;
  private:
  bool _internal_has_control_frame_type() const;
  public:
  void clear_control_frame_type();
  ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType control_frame_type() const;
  void set_control_frame_type(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType value);
  private:
  ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType _internal_control_frame_type() const;
  void _internal_set_control_frame_type(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType value);
  public:

  // .location.nearby.mediums.ConnectionRequestFrame connection_request_frame = 2;
  bool has_connection_request_frame() const;
  private:
  bool _internal_has_connection_request_frame() const;
  public:
  void clear_connection_request_frame();
  const ::location::nearby::mediums::ConnectionRequestFrame& connection_request_frame() const;
  PROTOBUF_NODISCARD ::location::nearby::mediums::ConnectionRequestFrame* release_connection_request_frame();
  ::location::nearby::mediums::ConnectionRequestFrame* mutable_connection_request_frame();
  void set_allocated_connection_request_frame(::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame);
  private:
  const ::location::nearby::mediums::ConnectionRequestFrame& _internal_connection_request_frame() const;
  ::location::nearby::mediums::ConnectionRequestFrame* _internal_mutable_connection_request_frame();
  public:
  void unsafe_arena_set_allocated_connection_request_frame(
      ::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame);
  ::location::nearby::mediums::ConnectionRequestFrame* unsafe_arena_release_connection_request_frame();

  // .location.nearby.mediums.ConnectionResponseFrame connection_response_frame = 3;
  bool has_connection_response_frame() const;
  private:
  bool _internal_has_connection_response_frame() const;
  public:
  void clear_connection_response_frame();
  const ::location::nearby::mediums::ConnectionResponseFrame& connection_response_frame() const;
  PROTOBUF_NODISCARD ::location::nearby::mediums::ConnectionResponseFrame* release_connection_response_frame();
  ::location::nearby::mediums::ConnectionResponseFrame* mutable_connection_response_frame();
  void set_allocated_connection_response_frame(::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame);
  private:
  const ::location::nearby::mediums::ConnectionResponseFrame& _internal_connection_response_frame() const;
  ::location::nearby::mediums::ConnectionResponseFrame* _internal_mutable_connection_response_frame();
  public:
  void unsafe_arena_set_allocated_connection_response_frame(
      ::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame);
  ::location::nearby::mediums::ConnectionResponseFrame* unsafe_arena_release_connection_response_frame();

  // .location.nearby.mediums.DisconnectFrame disconnect_frame = 4;
  bool has_disconnect_frame() const;
  private:
  bool _internal_has_disconnect_frame() const;
  public:
  void clear_disconnect_frame();
  const ::location::nearby::mediums::DisconnectFrame& disconnect_frame() const;
  PROTOBUF_NODISCARD ::location::nearby::mediums::DisconnectFrame* release_disconnect_frame();
  ::location::nearby::mediums::DisconnectFrame* mutable_disconnect_frame();
  void set_allocated_disconnect_frame(::location::nearby::mediums::DisconnectFrame* disconnect_frame);
  private:
  const ::location::nearby::mediums::DisconnectFrame& _internal_disconnect_frame() const;
  ::location::nearby::mediums::DisconnectFrame* _internal_mutable_disconnect_frame();
  public:
  void unsafe_arena_set_allocated_disconnect_frame(
      ::location::nearby::mediums::DisconnectFrame* disconnect_frame);
  ::location::nearby::mediums::DisconnectFrame* unsafe_arena_release_disconnect_frame();

  void clear_Frame();
  FrameCase Frame_case() const;
  // @@protoc_insertion_point(class_scope:location.nearby.mediums.MultiplexControlFrame)
 private:
  class _Internal;
  void set_has_connection_request_frame();
  void set_has_connection_response_frame();
  void set_has_disconnect_frame();

  inline bool has_Frame() const;
  inline void clear_has_Frame();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int control_frame_type_;
  union FrameUnion {
    constexpr FrameUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame_;
    ::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame_;
    ::location::nearby::mediums::DisconnectFrame* disconnect_frame_;
  } Frame_;
  uint32_t _oneof_case_[1];

  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
};
// -------------------------------------------------------------------

class ConnectionRequestFrame final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.ConnectionRequestFrame) */ {
 public:
  inline ConnectionRequestFrame() : ConnectionRequestFrame(nullptr) {}
  ~ConnectionRequestFrame() override;
  explicit constexpr ConnectionRequestFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ConnectionRequestFrame(const ConnectionRequestFrame& from);
  ConnectionRequestFrame(ConnectionRequestFrame&& from) noexcept
    : ConnectionRequestFrame() {
    *this = ::std::move(from);
  }

  inline ConnectionRequestFrame& operator=(const ConnectionRequestFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConnectionRequestFrame& operator=(ConnectionRequestFrame&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const ConnectionRequestFrame& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConnectionRequestFrame* internal_default_instance() {
    return reinterpret_cast<const ConnectionRequestFrame*>(
               &_ConnectionRequestFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ConnectionRequestFrame& a, ConnectionRequestFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(ConnectionRequestFrame* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConnectionRequestFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ConnectionRequestFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ConnectionRequestFrame>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ConnectionRequestFrame& from);
  void MergeFrom(const ConnectionRequestFrame& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ConnectionRequestFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "location.nearby.mediums.ConnectionRequestFrame";
  }
  protected:
  explicit ConnectionRequestFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:location.nearby.mediums.ConnectionRequestFrame)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
};
// -------------------------------------------------------------------

class ConnectionResponseFrame final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.ConnectionResponseFrame) */ {
 public:
  inline ConnectionResponseFrame() : ConnectionResponseFrame(nullptr) {}
  ~ConnectionResponseFrame() override;
  explicit constexpr ConnectionResponseFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ConnectionResponseFrame(const ConnectionResponseFrame& from);
  ConnectionResponseFrame(ConnectionResponseFrame&& from) noexcept
    : ConnectionResponseFrame() {
    *this = ::std::move(from);
  }

  inline ConnectionResponseFrame& operator=(const ConnectionResponseFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConnectionResponseFrame& operator=(ConnectionResponseFrame&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const ConnectionResponseFrame& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConnectionResponseFrame* internal_default_instance() {
    return reinterpret_cast<const ConnectionResponseFrame*>(
               &_ConnectionResponseFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(ConnectionResponseFrame& a, ConnectionResponseFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(ConnectionResponseFrame* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConnectionResponseFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  ConnectionResponseFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ConnectionResponseFrame>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const ConnectionResponseFrame& from);
  void MergeFrom(const ConnectionResponseFrame& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ConnectionResponseFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "location.nearby.mediums.ConnectionResponseFrame";
  }
  protected:
  explicit ConnectionResponseFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseCode;
  static constexpr ConnectionResponseCode UNKNOWN_RESPONSE_CODE =
    ConnectionResponseFrame_ConnectionResponseCode_UNKNOWN_RESPONSE_CODE;
  static constexpr ConnectionResponseCode CONNECTION_ACCEPTED =
    ConnectionResponseFrame_ConnectionResponseCode_CONNECTION_ACCEPTED;
  static constexpr ConnectionResponseCode NOT_LISTENING =
    ConnectionResponseFrame_ConnectionResponseCode_NOT_LISTENING;
  static inline bool ConnectionResponseCode_IsValid(int value) {
    return ConnectionResponseFrame_ConnectionResponseCode_IsValid(value);
  }
  static constexpr ConnectionResponseCode ConnectionResponseCode_MIN =
    ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MIN;
  static constexpr ConnectionResponseCode ConnectionResponseCode_MAX =
    ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_MAX;
  static constexpr int ConnectionResponseCode_ARRAYSIZE =
    ConnectionResponseFrame_ConnectionResponseCode_ConnectionResponseCode_ARRAYSIZE;
  template<typename T>
  static inline const std::string& ConnectionResponseCode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ConnectionResponseCode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ConnectionResponseCode_Name.");
    return ConnectionResponseFrame_ConnectionResponseCode_Name(enum_t_value);
  }
  static inline bool ConnectionResponseCode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ConnectionResponseCode* value) {
    return ConnectionResponseFrame_ConnectionResponseCode_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kConnectionResponseCodeFieldNumber = 1,
  };
  // optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
  bool has_connection_response_code() const;
  private:
  bool _internal_has_connection_response_code() const;
  public:
  void clear_connection_response_code();
  ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode connection_response_code() const;
  void set_connection_response_code(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode value);
  private:
  ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode _internal_connection_response_code() const;
  void _internal_set_connection_response_code(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode value);
  public:

  // @@protoc_insertion_point(class_scope:location.nearby.mediums.ConnectionResponseFrame)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  int connection_response_code_;
  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
};
// -------------------------------------------------------------------

class DisconnectFrame final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.DisconnectFrame) */ {
 public:
  inline DisconnectFrame() : DisconnectFrame(nullptr) {}
  ~DisconnectFrame() override;
  explicit constexpr DisconnectFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DisconnectFrame(const DisconnectFrame& from);
  DisconnectFrame(DisconnectFrame&& from) noexcept
    : DisconnectFrame() {
    *this = ::std::move(from);
  }

  inline DisconnectFrame& operator=(const DisconnectFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline DisconnectFrame& operator=(DisconnectFrame&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const DisconnectFrame& default_instance() {
    return *internal_default_instance();
  }
  static inline const DisconnectFrame* internal_default_instance() {
    return reinterpret_cast<const DisconnectFrame*>(
               &_DisconnectFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(DisconnectFrame& a, DisconnectFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(DisconnectFrame* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DisconnectFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  DisconnectFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DisconnectFrame>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const DisconnectFrame& from);
  void MergeFrom(const DisconnectFrame& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DisconnectFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "location.nearby.mediums.DisconnectFrame";
  }
  protected:
  explicit DisconnectFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:location.nearby.mediums.DisconnectFrame)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
};
// -------------------------------------------------------------------

class MultiplexDataFrame final :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:location.nearby.mediums.MultiplexDataFrame) */ {
 public:
  inline MultiplexDataFrame() : MultiplexDataFrame(nullptr) {}
  ~MultiplexDataFrame() override;
  explicit constexpr MultiplexDataFrame(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MultiplexDataFrame(const MultiplexDataFrame& from);
  MultiplexDataFrame(MultiplexDataFrame&& from) noexcept
    : MultiplexDataFrame() {
    *this = ::std::move(from);
  }

  inline MultiplexDataFrame& operator=(const MultiplexDataFrame& from) {
    CopyFrom(from);
    return *this;
  }
  inline MultiplexDataFrame& operator=(MultiplexDataFrame&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<std::string>();
  }

  static const MultiplexDataFrame& default_instance() {
    return *internal_default_instance();
  }
  static inline const MultiplexDataFrame* internal_default_instance() {
    return reinterpret_cast<const MultiplexDataFrame*>(
               &_MultiplexDataFrame_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(MultiplexDataFrame& a, MultiplexDataFrame& b) {
    a.Swap(&b);
  }
  inline void Swap(MultiplexDataFrame* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(MultiplexDataFrame* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  MultiplexDataFrame* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<MultiplexDataFrame>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
  void CopyFrom(const MultiplexDataFrame& from);
  void MergeFrom(const MultiplexDataFrame& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MultiplexDataFrame* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "location.nearby.mediums.MultiplexDataFrame";
  }
  protected:
  explicit MultiplexDataFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
  };
  // optional bytes data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // @@protoc_insertion_point(class_scope:location.nearby.mediums.MultiplexDataFrame)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
  friend struct ::TableStruct_proto_2fmediums_2fmultiplex_5fframes_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// MultiplexFrame

// optional .location.nearby.mediums.MultiplexFrameHeader header = 1;
inline bool MultiplexFrame::_internal_has_header() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || header_ != nullptr);
  return value;
}
inline bool MultiplexFrame::has_header() const {
  return _internal_has_header();
}
inline void MultiplexFrame::clear_header() {
  if (header_ != nullptr) header_->Clear();
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::location::nearby::mediums::MultiplexFrameHeader& MultiplexFrame::_internal_header() const {
  const ::location::nearby::mediums::MultiplexFrameHeader* p = header_;
  return p != nullptr ? *p : reinterpret_cast<const ::location::nearby::mediums::MultiplexFrameHeader&>(
      ::location::nearby::mediums::_MultiplexFrameHeader_default_instance_);
}
inline const ::location::nearby::mediums::MultiplexFrameHeader& MultiplexFrame::header() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrame.header)
  return _internal_header();
}
inline void MultiplexFrame::unsafe_arena_set_allocated_header(
    ::location::nearby::mediums::MultiplexFrameHeader* header) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header_);
  }
  header_ = header;
  if (header) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexFrame.header)
}
inline ::location::nearby::mediums::MultiplexFrameHeader* MultiplexFrame::release_header() {
  _has_bits_[0] &= ~0x00000001u;
  ::location::nearby::mediums::MultiplexFrameHeader* temp = header_;
  header_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::location::nearby::mediums::MultiplexFrameHeader* MultiplexFrame::unsafe_arena_release_header() {
  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrame.header)
  _has_bits_[0] &= ~0x00000001u;
  ::location::nearby::mediums::MultiplexFrameHeader* temp = header_;
  header_ = nullptr;
  return temp;
}
inline ::location::nearby::mediums::MultiplexFrameHeader* MultiplexFrame::_internal_mutable_header() {
  _has_bits_[0] |= 0x00000001u;
  if (header_ == nullptr) {
    auto* p = CreateMaybeMessage<::location::nearby::mediums::MultiplexFrameHeader>(GetArenaForAllocation());
    header_ = p;
  }
  return header_;
}
inline ::location::nearby::mediums::MultiplexFrameHeader* MultiplexFrame::mutable_header() {
  ::location::nearby::mediums::MultiplexFrameHeader* _msg = _internal_mutable_header();
  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrame.header)
  return _msg;
}
inline void MultiplexFrame::set_allocated_header(::location::nearby::mediums::MultiplexFrameHeader* header) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete header_;
  }
  if (header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::location::nearby::mediums::MultiplexFrameHeader>::GetOwningArena(header);
    if (message_arena != submessage_arena) {
      header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, header, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  header_ = header;
  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrame.header)
}

// optional .location.nearby.mediums.MultiplexFrame.MultiplexFrameType frame_type = 2;
inline bool MultiplexFrame::_internal_has_frame_type() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MultiplexFrame::has_frame_type() const {
  return _internal_has_frame_type();
}
inline void MultiplexFrame::clear_frame_type() {
  frame_type_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType MultiplexFrame::_internal_frame_type() const {
  return static_cast< ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType >(frame_type_);
}
inline ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType MultiplexFrame::frame_type() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrame.frame_type)
  return _internal_frame_type();
}
inline void MultiplexFrame::_internal_set_frame_type(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType value) {
  assert(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  frame_type_ = value;
}
inline void MultiplexFrame::set_frame_type(::location::nearby::mediums::MultiplexFrame_MultiplexFrameType value) {
  _internal_set_frame_type(value);
  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexFrame.frame_type)
}

// .location.nearby.mediums.MultiplexControlFrame control_frame = 3;
inline bool MultiplexFrame::_internal_has_control_frame() const {
  return Frame_case() == kControlFrame;
}
inline bool MultiplexFrame::has_control_frame() const {
  return _internal_has_control_frame();
}
inline void MultiplexFrame::set_has_control_frame() {
  _oneof_case_[0] = kControlFrame;
}
inline void MultiplexFrame::clear_control_frame() {
  if (_internal_has_control_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Frame_.control_frame_;
    }
    clear_has_Frame();
  }
}
inline ::location::nearby::mediums::MultiplexControlFrame* MultiplexFrame::release_control_frame() {
  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrame.control_frame)
  if (_internal_has_control_frame()) {
    clear_has_Frame();
      ::location::nearby::mediums::MultiplexControlFrame* temp = Frame_.control_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Frame_.control_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::location::nearby::mediums::MultiplexControlFrame& MultiplexFrame::_internal_control_frame() const {
  return _internal_has_control_frame()
      ? *Frame_.control_frame_
      : reinterpret_cast< ::location::nearby::mediums::MultiplexControlFrame&>(::location::nearby::mediums::_MultiplexControlFrame_default_instance_);
}
inline const ::location::nearby::mediums::MultiplexControlFrame& MultiplexFrame::control_frame() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrame.control_frame)
  return _internal_control_frame();
}
inline ::location::nearby::mediums::MultiplexControlFrame* MultiplexFrame::unsafe_arena_release_control_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexFrame.control_frame)
  if (_internal_has_control_frame()) {
    clear_has_Frame();
    ::location::nearby::mediums::MultiplexControlFrame* temp = Frame_.control_frame_;
    Frame_.control_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MultiplexFrame::unsafe_arena_set_allocated_control_frame(::location::nearby::mediums::MultiplexControlFrame* control_frame) {
  clear_Frame();
  if (control_frame) {
    set_has_control_frame();
    Frame_.control_frame_ = control_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexFrame.control_frame)
}
inline ::location::nearby::mediums::MultiplexControlFrame* MultiplexFrame::_internal_mutable_control_frame() {
  if (!_internal_has_control_frame()) {
    clear_Frame();
    set_has_control_frame();
    Frame_.control_frame_ = CreateMaybeMessage< ::location::nearby::mediums::MultiplexControlFrame >(GetArenaForAllocation());
  }
  return Frame_.control_frame_;
}
inline ::location::nearby::mediums::MultiplexControlFrame* MultiplexFrame::mutable_control_frame() {
  ::location::nearby::mediums::MultiplexControlFrame* _msg = _internal_mutable_control_frame();
  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrame.control_frame)
  return _msg;
}

// .location.nearby.mediums.MultiplexDataFrame data_frame = 4;
inline bool MultiplexFrame::_internal_has_data_frame() const {
  return Frame_case() == kDataFrame;
}
inline bool MultiplexFrame::has_data_frame() const {
  return _internal_has_data_frame();
}
inline void MultiplexFrame::set_has_data_frame() {
  _oneof_case_[0] = kDataFrame;
}
inline void MultiplexFrame::clear_data_frame() {
  if (_internal_has_data_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Frame_.data_frame_;
    }
    clear_has_Frame();
  }
}
inline ::location::nearby::mediums::MultiplexDataFrame* MultiplexFrame::release_data_frame() {
  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrame.data_frame)
  if (_internal_has_data_frame()) {
    clear_has_Frame();
      ::location::nearby::mediums::MultiplexDataFrame* temp = Frame_.data_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Frame_.data_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::location::nearby::mediums::MultiplexDataFrame& MultiplexFrame::_internal_data_frame() const {
  return _internal_has_data_frame()
      ? *Frame_.data_frame_
      : reinterpret_cast< ::location::nearby::mediums::MultiplexDataFrame&>(::location::nearby::mediums::_MultiplexDataFrame_default_instance_);
}
inline const ::location::nearby::mediums::MultiplexDataFrame& MultiplexFrame::data_frame() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrame.data_frame)
  return _internal_data_frame();
}
inline ::location::nearby::mediums::MultiplexDataFrame* MultiplexFrame::unsafe_arena_release_data_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexFrame.data_frame)
  if (_internal_has_data_frame()) {
    clear_has_Frame();
    ::location::nearby::mediums::MultiplexDataFrame* temp = Frame_.data_frame_;
    Frame_.data_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MultiplexFrame::unsafe_arena_set_allocated_data_frame(::location::nearby::mediums::MultiplexDataFrame* data_frame) {
  clear_Frame();
  if (data_frame) {
    set_has_data_frame();
    Frame_.data_frame_ = data_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexFrame.data_frame)
}
inline ::location::nearby::mediums::MultiplexDataFrame* MultiplexFrame::_internal_mutable_data_frame() {
  if (!_internal_has_data_frame()) {
    clear_Frame();
    set_has_data_frame();
    Frame_.data_frame_ = CreateMaybeMessage< ::location::nearby::mediums::MultiplexDataFrame >(GetArenaForAllocation());
  }
  return Frame_.data_frame_;
}
inline ::location::nearby::mediums::MultiplexDataFrame* MultiplexFrame::mutable_data_frame() {
  ::location::nearby::mediums::MultiplexDataFrame* _msg = _internal_mutable_data_frame();
  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrame.data_frame)
  return _msg;
}

inline bool MultiplexFrame::has_Frame() const {
  return Frame_case() != FRAME_NOT_SET;
}
inline void MultiplexFrame::clear_has_Frame() {
  _oneof_case_[0] = FRAME_NOT_SET;
}
inline MultiplexFrame::FrameCase MultiplexFrame::Frame_case() const {
  return MultiplexFrame::FrameCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// MultiplexFrameHeader

// optional bytes salted_service_id_hash = 1;
inline bool MultiplexFrameHeader::_internal_has_salted_service_id_hash() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MultiplexFrameHeader::has_salted_service_id_hash() const {
  return _internal_has_salted_service_id_hash();
}
inline void MultiplexFrameHeader::clear_salted_service_id_hash() {
  salted_service_id_hash_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MultiplexFrameHeader::salted_service_id_hash() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
  return _internal_salted_service_id_hash();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MultiplexFrameHeader::set_salted_service_id_hash(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 salted_service_id_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
}
inline std::string* MultiplexFrameHeader::mutable_salted_service_id_hash() {
  std::string* _s = _internal_mutable_salted_service_id_hash();
  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
  return _s;
}
inline const std::string& MultiplexFrameHeader::_internal_salted_service_id_hash() const {
  return salted_service_id_hash_.Get();
}
inline void MultiplexFrameHeader::_internal_set_salted_service_id_hash(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  salted_service_id_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MultiplexFrameHeader::_internal_mutable_salted_service_id_hash() {
  _has_bits_[0] |= 0x00000001u;
  return salted_service_id_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MultiplexFrameHeader::release_salted_service_id_hash() {
  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
  if (!_internal_has_salted_service_id_hash()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = salted_service_id_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (salted_service_id_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    salted_service_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MultiplexFrameHeader::set_allocated_salted_service_id_hash(std::string* salted_service_id_hash) {
  if (salted_service_id_hash != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  salted_service_id_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), salted_service_id_hash,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (salted_service_id_hash_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    salted_service_id_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrameHeader.salted_service_id_hash)
}

// optional string service_id_hash_salt = 2;
inline bool MultiplexFrameHeader::_internal_has_service_id_hash_salt() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool MultiplexFrameHeader::has_service_id_hash_salt() const {
  return _internal_has_service_id_hash_salt();
}
inline void MultiplexFrameHeader::clear_service_id_hash_salt() {
  service_id_hash_salt_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& MultiplexFrameHeader::service_id_hash_salt() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
  return _internal_service_id_hash_salt();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MultiplexFrameHeader::set_service_id_hash_salt(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 service_id_hash_salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
}
inline std::string* MultiplexFrameHeader::mutable_service_id_hash_salt() {
  std::string* _s = _internal_mutable_service_id_hash_salt();
  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
  return _s;
}
inline const std::string& MultiplexFrameHeader::_internal_service_id_hash_salt() const {
  return service_id_hash_salt_.Get();
}
inline void MultiplexFrameHeader::_internal_set_service_id_hash_salt(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  service_id_hash_salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MultiplexFrameHeader::_internal_mutable_service_id_hash_salt() {
  _has_bits_[0] |= 0x00000002u;
  return service_id_hash_salt_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MultiplexFrameHeader::release_service_id_hash_salt() {
  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
  if (!_internal_has_service_id_hash_salt()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = service_id_hash_salt_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (service_id_hash_salt_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MultiplexFrameHeader::set_allocated_service_id_hash_salt(std::string* service_id_hash_salt) {
  if (service_id_hash_salt != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  service_id_hash_salt_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id_hash_salt,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (service_id_hash_salt_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    service_id_hash_salt_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexFrameHeader.service_id_hash_salt)
}

// -------------------------------------------------------------------

// MultiplexControlFrame

// optional .location.nearby.mediums.MultiplexControlFrame.MultiplexControlFrameType control_frame_type = 1;
inline bool MultiplexControlFrame::_internal_has_control_frame_type() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MultiplexControlFrame::has_control_frame_type() const {
  return _internal_has_control_frame_type();
}
inline void MultiplexControlFrame::clear_control_frame_type() {
  control_frame_type_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::_internal_control_frame_type() const {
  return static_cast< ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType >(control_frame_type_);
}
inline ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType MultiplexControlFrame::control_frame_type() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexControlFrame.control_frame_type)
  return _internal_control_frame_type();
}
inline void MultiplexControlFrame::_internal_set_control_frame_type(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType value) {
  assert(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  control_frame_type_ = value;
}
inline void MultiplexControlFrame::set_control_frame_type(::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType value) {
  _internal_set_control_frame_type(value);
  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexControlFrame.control_frame_type)
}

// .location.nearby.mediums.ConnectionRequestFrame connection_request_frame = 2;
inline bool MultiplexControlFrame::_internal_has_connection_request_frame() const {
  return Frame_case() == kConnectionRequestFrame;
}
inline bool MultiplexControlFrame::has_connection_request_frame() const {
  return _internal_has_connection_request_frame();
}
inline void MultiplexControlFrame::set_has_connection_request_frame() {
  _oneof_case_[0] = kConnectionRequestFrame;
}
inline void MultiplexControlFrame::clear_connection_request_frame() {
  if (_internal_has_connection_request_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Frame_.connection_request_frame_;
    }
    clear_has_Frame();
  }
}
inline ::location::nearby::mediums::ConnectionRequestFrame* MultiplexControlFrame::release_connection_request_frame() {
  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
  if (_internal_has_connection_request_frame()) {
    clear_has_Frame();
      ::location::nearby::mediums::ConnectionRequestFrame* temp = Frame_.connection_request_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Frame_.connection_request_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::location::nearby::mediums::ConnectionRequestFrame& MultiplexControlFrame::_internal_connection_request_frame() const {
  return _internal_has_connection_request_frame()
      ? *Frame_.connection_request_frame_
      : reinterpret_cast< ::location::nearby::mediums::ConnectionRequestFrame&>(::location::nearby::mediums::_ConnectionRequestFrame_default_instance_);
}
inline const ::location::nearby::mediums::ConnectionRequestFrame& MultiplexControlFrame::connection_request_frame() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
  return _internal_connection_request_frame();
}
inline ::location::nearby::mediums::ConnectionRequestFrame* MultiplexControlFrame::unsafe_arena_release_connection_request_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
  if (_internal_has_connection_request_frame()) {
    clear_has_Frame();
    ::location::nearby::mediums::ConnectionRequestFrame* temp = Frame_.connection_request_frame_;
    Frame_.connection_request_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MultiplexControlFrame::unsafe_arena_set_allocated_connection_request_frame(::location::nearby::mediums::ConnectionRequestFrame* connection_request_frame) {
  clear_Frame();
  if (connection_request_frame) {
    set_has_connection_request_frame();
    Frame_.connection_request_frame_ = connection_request_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
}
inline ::location::nearby::mediums::ConnectionRequestFrame* MultiplexControlFrame::_internal_mutable_connection_request_frame() {
  if (!_internal_has_connection_request_frame()) {
    clear_Frame();
    set_has_connection_request_frame();
    Frame_.connection_request_frame_ = CreateMaybeMessage< ::location::nearby::mediums::ConnectionRequestFrame >(GetArenaForAllocation());
  }
  return Frame_.connection_request_frame_;
}
inline ::location::nearby::mediums::ConnectionRequestFrame* MultiplexControlFrame::mutable_connection_request_frame() {
  ::location::nearby::mediums::ConnectionRequestFrame* _msg = _internal_mutable_connection_request_frame();
  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexControlFrame.connection_request_frame)
  return _msg;
}

// .location.nearby.mediums.ConnectionResponseFrame connection_response_frame = 3;
inline bool MultiplexControlFrame::_internal_has_connection_response_frame() const {
  return Frame_case() == kConnectionResponseFrame;
}
inline bool MultiplexControlFrame::has_connection_response_frame() const {
  return _internal_has_connection_response_frame();
}
inline void MultiplexControlFrame::set_has_connection_response_frame() {
  _oneof_case_[0] = kConnectionResponseFrame;
}
inline void MultiplexControlFrame::clear_connection_response_frame() {
  if (_internal_has_connection_response_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Frame_.connection_response_frame_;
    }
    clear_has_Frame();
  }
}
inline ::location::nearby::mediums::ConnectionResponseFrame* MultiplexControlFrame::release_connection_response_frame() {
  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
  if (_internal_has_connection_response_frame()) {
    clear_has_Frame();
      ::location::nearby::mediums::ConnectionResponseFrame* temp = Frame_.connection_response_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Frame_.connection_response_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::location::nearby::mediums::ConnectionResponseFrame& MultiplexControlFrame::_internal_connection_response_frame() const {
  return _internal_has_connection_response_frame()
      ? *Frame_.connection_response_frame_
      : reinterpret_cast< ::location::nearby::mediums::ConnectionResponseFrame&>(::location::nearby::mediums::_ConnectionResponseFrame_default_instance_);
}
inline const ::location::nearby::mediums::ConnectionResponseFrame& MultiplexControlFrame::connection_response_frame() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
  return _internal_connection_response_frame();
}
inline ::location::nearby::mediums::ConnectionResponseFrame* MultiplexControlFrame::unsafe_arena_release_connection_response_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
  if (_internal_has_connection_response_frame()) {
    clear_has_Frame();
    ::location::nearby::mediums::ConnectionResponseFrame* temp = Frame_.connection_response_frame_;
    Frame_.connection_response_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MultiplexControlFrame::unsafe_arena_set_allocated_connection_response_frame(::location::nearby::mediums::ConnectionResponseFrame* connection_response_frame) {
  clear_Frame();
  if (connection_response_frame) {
    set_has_connection_response_frame();
    Frame_.connection_response_frame_ = connection_response_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
}
inline ::location::nearby::mediums::ConnectionResponseFrame* MultiplexControlFrame::_internal_mutable_connection_response_frame() {
  if (!_internal_has_connection_response_frame()) {
    clear_Frame();
    set_has_connection_response_frame();
    Frame_.connection_response_frame_ = CreateMaybeMessage< ::location::nearby::mediums::ConnectionResponseFrame >(GetArenaForAllocation());
  }
  return Frame_.connection_response_frame_;
}
inline ::location::nearby::mediums::ConnectionResponseFrame* MultiplexControlFrame::mutable_connection_response_frame() {
  ::location::nearby::mediums::ConnectionResponseFrame* _msg = _internal_mutable_connection_response_frame();
  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexControlFrame.connection_response_frame)
  return _msg;
}

// .location.nearby.mediums.DisconnectFrame disconnect_frame = 4;
inline bool MultiplexControlFrame::_internal_has_disconnect_frame() const {
  return Frame_case() == kDisconnectFrame;
}
inline bool MultiplexControlFrame::has_disconnect_frame() const {
  return _internal_has_disconnect_frame();
}
inline void MultiplexControlFrame::set_has_disconnect_frame() {
  _oneof_case_[0] = kDisconnectFrame;
}
inline void MultiplexControlFrame::clear_disconnect_frame() {
  if (_internal_has_disconnect_frame()) {
    if (GetArenaForAllocation() == nullptr) {
      delete Frame_.disconnect_frame_;
    }
    clear_has_Frame();
  }
}
inline ::location::nearby::mediums::DisconnectFrame* MultiplexControlFrame::release_disconnect_frame() {
  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
  if (_internal_has_disconnect_frame()) {
    clear_has_Frame();
      ::location::nearby::mediums::DisconnectFrame* temp = Frame_.disconnect_frame_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    Frame_.disconnect_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::location::nearby::mediums::DisconnectFrame& MultiplexControlFrame::_internal_disconnect_frame() const {
  return _internal_has_disconnect_frame()
      ? *Frame_.disconnect_frame_
      : reinterpret_cast< ::location::nearby::mediums::DisconnectFrame&>(::location::nearby::mediums::_DisconnectFrame_default_instance_);
}
inline const ::location::nearby::mediums::DisconnectFrame& MultiplexControlFrame::disconnect_frame() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
  return _internal_disconnect_frame();
}
inline ::location::nearby::mediums::DisconnectFrame* MultiplexControlFrame::unsafe_arena_release_disconnect_frame() {
  // @@protoc_insertion_point(field_unsafe_arena_release:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
  if (_internal_has_disconnect_frame()) {
    clear_has_Frame();
    ::location::nearby::mediums::DisconnectFrame* temp = Frame_.disconnect_frame_;
    Frame_.disconnect_frame_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void MultiplexControlFrame::unsafe_arena_set_allocated_disconnect_frame(::location::nearby::mediums::DisconnectFrame* disconnect_frame) {
  clear_Frame();
  if (disconnect_frame) {
    set_has_disconnect_frame();
    Frame_.disconnect_frame_ = disconnect_frame;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
}
inline ::location::nearby::mediums::DisconnectFrame* MultiplexControlFrame::_internal_mutable_disconnect_frame() {
  if (!_internal_has_disconnect_frame()) {
    clear_Frame();
    set_has_disconnect_frame();
    Frame_.disconnect_frame_ = CreateMaybeMessage< ::location::nearby::mediums::DisconnectFrame >(GetArenaForAllocation());
  }
  return Frame_.disconnect_frame_;
}
inline ::location::nearby::mediums::DisconnectFrame* MultiplexControlFrame::mutable_disconnect_frame() {
  ::location::nearby::mediums::DisconnectFrame* _msg = _internal_mutable_disconnect_frame();
  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexControlFrame.disconnect_frame)
  return _msg;
}

inline bool MultiplexControlFrame::has_Frame() const {
  return Frame_case() != FRAME_NOT_SET;
}
inline void MultiplexControlFrame::clear_has_Frame() {
  _oneof_case_[0] = FRAME_NOT_SET;
}
inline MultiplexControlFrame::FrameCase MultiplexControlFrame::Frame_case() const {
  return MultiplexControlFrame::FrameCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ConnectionRequestFrame

// -------------------------------------------------------------------

// ConnectionResponseFrame

// optional .location.nearby.mediums.ConnectionResponseFrame.ConnectionResponseCode connection_response_code = 1;
inline bool ConnectionResponseFrame::_internal_has_connection_response_code() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool ConnectionResponseFrame::has_connection_response_code() const {
  return _internal_has_connection_response_code();
}
inline void ConnectionResponseFrame::clear_connection_response_code() {
  connection_response_code_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::_internal_connection_response_code() const {
  return static_cast< ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode >(connection_response_code_);
}
inline ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode ConnectionResponseFrame::connection_response_code() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.ConnectionResponseFrame.connection_response_code)
  return _internal_connection_response_code();
}
inline void ConnectionResponseFrame::_internal_set_connection_response_code(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode value) {
  assert(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  connection_response_code_ = value;
}
inline void ConnectionResponseFrame::set_connection_response_code(::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode value) {
  _internal_set_connection_response_code(value);
  // @@protoc_insertion_point(field_set:location.nearby.mediums.ConnectionResponseFrame.connection_response_code)
}

// -------------------------------------------------------------------

// DisconnectFrame

// -------------------------------------------------------------------

// MultiplexDataFrame

// optional bytes data = 1;
inline bool MultiplexDataFrame::_internal_has_data() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool MultiplexDataFrame::has_data() const {
  return _internal_has_data();
}
inline void MultiplexDataFrame::clear_data() {
  data_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& MultiplexDataFrame::data() const {
  // @@protoc_insertion_point(field_get:location.nearby.mediums.MultiplexDataFrame.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void MultiplexDataFrame::set_data(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:location.nearby.mediums.MultiplexDataFrame.data)
}
inline std::string* MultiplexDataFrame::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:location.nearby.mediums.MultiplexDataFrame.data)
  return _s;
}
inline const std::string& MultiplexDataFrame::_internal_data() const {
  return data_.Get();
}
inline void MultiplexDataFrame::_internal_set_data(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* MultiplexDataFrame::_internal_mutable_data() {
  _has_bits_[0] |= 0x00000001u;
  return data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* MultiplexDataFrame::release_data() {
  // @@protoc_insertion_point(field_release:location.nearby.mediums.MultiplexDataFrame.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  auto* p = data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void MultiplexDataFrame::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (data_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:location.nearby.mediums.MultiplexDataFrame.data)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace mediums
}  // namespace nearby
}  // namespace location

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::location::nearby::mediums::MultiplexFrame_MultiplexFrameType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::mediums::MultiplexControlFrame_MultiplexControlFrameType> : ::std::true_type {};
template <> struct is_proto_enum< ::location::nearby::mediums::ConnectionResponseFrame_ConnectionResponseCode> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_proto_2fmediums_2fmultiplex_5fframes_2eproto