chromium/out/Default/gen/google_apis/gcm/protocol/mcs.pb.cc

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

#include "mcs.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace mcs_proto {
PROTOBUF_CONSTEXPR HeartbeatPing::HeartbeatPing(
    ::_pbi::ConstantInitialized): … { … }
struct HeartbeatPingDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HeartbeatPingDefaultTypeInternal _HeartbeatPing_default_instance_;
PROTOBUF_CONSTEXPR HeartbeatAck::HeartbeatAck(
    ::_pbi::ConstantInitialized): … { … }
struct HeartbeatAckDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HeartbeatAckDefaultTypeInternal _HeartbeatAck_default_instance_;
PROTOBUF_CONSTEXPR ErrorInfo::ErrorInfo(
    ::_pbi::ConstantInitialized): … { … }
struct ErrorInfoDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ErrorInfoDefaultTypeInternal _ErrorInfo_default_instance_;
PROTOBUF_CONSTEXPR Setting::Setting(
    ::_pbi::ConstantInitialized): … { … }
struct SettingDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SettingDefaultTypeInternal _Setting_default_instance_;
PROTOBUF_CONSTEXPR HeartbeatStat::HeartbeatStat(
    ::_pbi::ConstantInitialized): … { … }
struct HeartbeatStatDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HeartbeatStatDefaultTypeInternal _HeartbeatStat_default_instance_;
PROTOBUF_CONSTEXPR HeartbeatConfig::HeartbeatConfig(
    ::_pbi::ConstantInitialized): … { … }
struct HeartbeatConfigDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HeartbeatConfigDefaultTypeInternal _HeartbeatConfig_default_instance_;
PROTOBUF_CONSTEXPR ClientEvent::ClientEvent(
    ::_pbi::ConstantInitialized): … { … }
struct ClientEventDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientEventDefaultTypeInternal _ClientEvent_default_instance_;
PROTOBUF_CONSTEXPR LoginRequest::LoginRequest(
    ::_pbi::ConstantInitialized): … { … }
struct LoginRequestDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoginRequestDefaultTypeInternal _LoginRequest_default_instance_;
PROTOBUF_CONSTEXPR LoginResponse::LoginResponse(
    ::_pbi::ConstantInitialized): … { … }
struct LoginResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LoginResponseDefaultTypeInternal _LoginResponse_default_instance_;
PROTOBUF_CONSTEXPR StreamErrorStanza::StreamErrorStanza(
    ::_pbi::ConstantInitialized): … { … }
struct StreamErrorStanzaDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StreamErrorStanzaDefaultTypeInternal _StreamErrorStanza_default_instance_;
PROTOBUF_CONSTEXPR Close::Close(
    ::_pbi::ConstantInitialized): … { … }
struct CloseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CloseDefaultTypeInternal _Close_default_instance_;
PROTOBUF_CONSTEXPR Extension::Extension(
    ::_pbi::ConstantInitialized): … { … }
struct ExtensionDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ExtensionDefaultTypeInternal _Extension_default_instance_;
PROTOBUF_CONSTEXPR IqStanza::IqStanza(
    ::_pbi::ConstantInitialized): … { … }
struct IqStanzaDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IqStanzaDefaultTypeInternal _IqStanza_default_instance_;
PROTOBUF_CONSTEXPR AppData::AppData(
    ::_pbi::ConstantInitialized): … { … }
struct AppDataDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AppDataDefaultTypeInternal _AppData_default_instance_;
PROTOBUF_CONSTEXPR DataMessageStanza::DataMessageStanza(
    ::_pbi::ConstantInitialized): … { … }
struct DataMessageStanzaDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DataMessageStanzaDefaultTypeInternal _DataMessageStanza_default_instance_;
PROTOBUF_CONSTEXPR StreamAck::StreamAck(
    ::_pbi::ConstantInitialized): … { … }
struct StreamAckDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StreamAckDefaultTypeInternal _StreamAck_default_instance_;
PROTOBUF_CONSTEXPR SelectiveAck::SelectiveAck(
    ::_pbi::ConstantInitialized): … { … }
struct SelectiveAckDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SelectiveAckDefaultTypeInternal _SelectiveAck_default_instance_;
}  // namespace mcs_proto
namespace mcs_proto {
bool ClientEvent_Type_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientEvent_Type_strings[4] = …;

static const char ClientEvent_Type_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientEvent_Type_entries[] = …;

static const int ClientEvent_Type_entries_by_number[] = …;

const std::string& ClientEvent_Type_Name(
    ClientEvent_Type value) { … }
bool ClientEvent_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientEvent_Type* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr ClientEvent_Type ClientEvent::UNKNOWN;
constexpr ClientEvent_Type ClientEvent::DISCARDED_EVENTS;
constexpr ClientEvent_Type ClientEvent::FAILED_CONNECTION;
constexpr ClientEvent_Type ClientEvent::SUCCESSFUL_CONNECTION;
constexpr ClientEvent_Type ClientEvent::Type_MIN;
constexpr ClientEvent_Type ClientEvent::Type_MAX;
constexpr int ClientEvent::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool LoginRequest_AuthService_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> LoginRequest_AuthService_strings[1] = …;

static const char LoginRequest_AuthService_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry LoginRequest_AuthService_entries[] = …;

static const int LoginRequest_AuthService_entries_by_number[] = …;

const std::string& LoginRequest_AuthService_Name(
    LoginRequest_AuthService value) { … }
bool LoginRequest_AuthService_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LoginRequest_AuthService* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr LoginRequest_AuthService LoginRequest::ANDROID_ID;
constexpr LoginRequest_AuthService LoginRequest::AuthService_MIN;
constexpr LoginRequest_AuthService LoginRequest::AuthService_MAX;
constexpr int LoginRequest::AuthService_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool IqStanza_IqType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> IqStanza_IqType_strings[4] = …;

static const char IqStanza_IqType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry IqStanza_IqType_entries[] = …;

static const int IqStanza_IqType_entries_by_number[] = …;

const std::string& IqStanza_IqType_Name(
    IqStanza_IqType value) { … }
bool IqStanza_IqType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, IqStanza_IqType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr IqStanza_IqType IqStanza::GET;
constexpr IqStanza_IqType IqStanza::SET;
constexpr IqStanza_IqType IqStanza::RESULT;
constexpr IqStanza_IqType IqStanza::IQ_ERROR;
constexpr IqStanza_IqType IqStanza::IqType_MIN;
constexpr IqStanza_IqType IqStanza::IqType_MAX;
constexpr int IqStanza::IqType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class HeartbeatPing::_Internal { … };

HeartbeatPing::HeartbeatPing(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
HeartbeatPing::HeartbeatPing(const HeartbeatPing& from)
  : … { … }

inline void HeartbeatPing::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

HeartbeatPing::~HeartbeatPing() { … }

inline void HeartbeatPing::SharedDtor() { … }

void HeartbeatPing::SetCachedSize(int size) const { … }

void HeartbeatPing::Clear() { … }

const char* HeartbeatPing::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* HeartbeatPing::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t HeartbeatPing::ByteSizeLong() const { … }

void HeartbeatPing::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void HeartbeatPing::MergeFrom(const HeartbeatPing& from) { … }

void HeartbeatPing::CopyFrom(const HeartbeatPing& from) { … }

bool HeartbeatPing::IsInitialized() const { … }

void HeartbeatPing::InternalSwap(HeartbeatPing* other) { … }

std::string HeartbeatPing::GetTypeName() const { … }


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

class HeartbeatAck::_Internal { … };

HeartbeatAck::HeartbeatAck(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
HeartbeatAck::HeartbeatAck(const HeartbeatAck& from)
  : … { … }

inline void HeartbeatAck::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

HeartbeatAck::~HeartbeatAck() { … }

inline void HeartbeatAck::SharedDtor() { … }

void HeartbeatAck::SetCachedSize(int size) const { … }

void HeartbeatAck::Clear() { … }

const char* HeartbeatAck::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* HeartbeatAck::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t HeartbeatAck::ByteSizeLong() const { … }

void HeartbeatAck::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void HeartbeatAck::MergeFrom(const HeartbeatAck& from) { … }

void HeartbeatAck::CopyFrom(const HeartbeatAck& from) { … }

bool HeartbeatAck::IsInitialized() const { … }

void HeartbeatAck::InternalSwap(HeartbeatAck* other) { … }

std::string HeartbeatAck::GetTypeName() const { … }


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

class ErrorInfo::_Internal { … };

const ::mcs_proto::Extension&
ErrorInfo::_Internal::extension(const ErrorInfo* msg) { … }
ErrorInfo::ErrorInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ErrorInfo::ErrorInfo(const ErrorInfo& from)
  : … { … }

inline void ErrorInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ErrorInfo::~ErrorInfo() { … }

inline void ErrorInfo::SharedDtor() { … }

void ErrorInfo::SetCachedSize(int size) const { … }

void ErrorInfo::Clear() { … }

const char* ErrorInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ErrorInfo::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ErrorInfo::ByteSizeLong() const { … }

void ErrorInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ErrorInfo::MergeFrom(const ErrorInfo& from) { … }

void ErrorInfo::CopyFrom(const ErrorInfo& from) { … }

bool ErrorInfo::IsInitialized() const { … }

void ErrorInfo::InternalSwap(ErrorInfo* other) { … }

std::string ErrorInfo::GetTypeName() const { … }


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

class Setting::_Internal { … };

Setting::Setting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
Setting::Setting(const Setting& from)
  : … { … }

inline void Setting::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

Setting::~Setting() { … }

inline void Setting::SharedDtor() { … }

void Setting::SetCachedSize(int size) const { … }

void Setting::Clear() { … }

const char* Setting::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* Setting::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t Setting::RequiredFieldsByteSizeFallback() const { … }
size_t Setting::ByteSizeLong() const { … }

void Setting::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void Setting::MergeFrom(const Setting& from) { … }

void Setting::CopyFrom(const Setting& from) { … }

bool Setting::IsInitialized() const { … }

void Setting::InternalSwap(Setting* other) { … }

std::string Setting::GetTypeName() const { … }


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

class HeartbeatStat::_Internal { … };

HeartbeatStat::HeartbeatStat(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
HeartbeatStat::HeartbeatStat(const HeartbeatStat& from)
  : … { … }

inline void HeartbeatStat::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

HeartbeatStat::~HeartbeatStat() { … }

inline void HeartbeatStat::SharedDtor() { … }

void HeartbeatStat::SetCachedSize(int size) const { … }

void HeartbeatStat::Clear() { … }

const char* HeartbeatStat::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* HeartbeatStat::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t HeartbeatStat::RequiredFieldsByteSizeFallback() const { … }
size_t HeartbeatStat::ByteSizeLong() const { … }

void HeartbeatStat::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void HeartbeatStat::MergeFrom(const HeartbeatStat& from) { … }

void HeartbeatStat::CopyFrom(const HeartbeatStat& from) { … }

bool HeartbeatStat::IsInitialized() const { … }

void HeartbeatStat::InternalSwap(HeartbeatStat* other) { … }

std::string HeartbeatStat::GetTypeName() const { … }


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

class HeartbeatConfig::_Internal { … };

HeartbeatConfig::HeartbeatConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
HeartbeatConfig::HeartbeatConfig(const HeartbeatConfig& from)
  : … { … }

inline void HeartbeatConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

HeartbeatConfig::~HeartbeatConfig() { … }

inline void HeartbeatConfig::SharedDtor() { … }

void HeartbeatConfig::SetCachedSize(int size) const { … }

void HeartbeatConfig::Clear() { … }

const char* HeartbeatConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* HeartbeatConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t HeartbeatConfig::ByteSizeLong() const { … }

void HeartbeatConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void HeartbeatConfig::MergeFrom(const HeartbeatConfig& from) { … }

void HeartbeatConfig::CopyFrom(const HeartbeatConfig& from) { … }

bool HeartbeatConfig::IsInitialized() const { … }

void HeartbeatConfig::InternalSwap(HeartbeatConfig* other) { … }

std::string HeartbeatConfig::GetTypeName() const { … }


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

class ClientEvent::_Internal { … };

ClientEvent::ClientEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ClientEvent::ClientEvent(const ClientEvent& from)
  : … { … }

inline void ClientEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ClientEvent::~ClientEvent() { … }

inline void ClientEvent::SharedDtor() { … }

void ClientEvent::SetCachedSize(int size) const { … }

void ClientEvent::Clear() { … }

const char* ClientEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ClientEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ClientEvent::ByteSizeLong() const { … }

void ClientEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ClientEvent::MergeFrom(const ClientEvent& from) { … }

void ClientEvent::CopyFrom(const ClientEvent& from) { … }

bool ClientEvent::IsInitialized() const { … }

void ClientEvent::InternalSwap(ClientEvent* other) { … }

std::string ClientEvent::GetTypeName() const { … }


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

class LoginRequest::_Internal { … };

const ::mcs_proto::HeartbeatStat&
LoginRequest::_Internal::heartbeat_stat(const LoginRequest* msg) { … }
LoginRequest::LoginRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
LoginRequest::LoginRequest(const LoginRequest& from)
  : … { … }

inline void LoginRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

LoginRequest::~LoginRequest() { … }

inline void LoginRequest::SharedDtor() { … }

void LoginRequest::SetCachedSize(int size) const { … }

void LoginRequest::Clear() { … }

const char* LoginRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* LoginRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t LoginRequest::RequiredFieldsByteSizeFallback() const { … }
size_t LoginRequest::ByteSizeLong() const { … }

void LoginRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void LoginRequest::MergeFrom(const LoginRequest& from) { … }

void LoginRequest::CopyFrom(const LoginRequest& from) { … }

bool LoginRequest::IsInitialized() const { … }

void LoginRequest::InternalSwap(LoginRequest* other) { … }

std::string LoginRequest::GetTypeName() const { … }


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

class LoginResponse::_Internal { … };

const ::mcs_proto::ErrorInfo&
LoginResponse::_Internal::error(const LoginResponse* msg) { … }
const ::mcs_proto::HeartbeatConfig&
LoginResponse::_Internal::heartbeat_config(const LoginResponse* msg) { … }
LoginResponse::LoginResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
LoginResponse::LoginResponse(const LoginResponse& from)
  : … { … }

inline void LoginResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

LoginResponse::~LoginResponse() { … }

inline void LoginResponse::SharedDtor() { … }

void LoginResponse::SetCachedSize(int size) const { … }

void LoginResponse::Clear() { … }

const char* LoginResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* LoginResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t LoginResponse::ByteSizeLong() const { … }

void LoginResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void LoginResponse::MergeFrom(const LoginResponse& from) { … }

void LoginResponse::CopyFrom(const LoginResponse& from) { … }

bool LoginResponse::IsInitialized() const { … }

void LoginResponse::InternalSwap(LoginResponse* other) { … }

std::string LoginResponse::GetTypeName() const { … }


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

class StreamErrorStanza::_Internal { … };

StreamErrorStanza::StreamErrorStanza(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
StreamErrorStanza::StreamErrorStanza(const StreamErrorStanza& from)
  : … { … }

inline void StreamErrorStanza::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

StreamErrorStanza::~StreamErrorStanza() { … }

inline void StreamErrorStanza::SharedDtor() { … }

void StreamErrorStanza::SetCachedSize(int size) const { … }

void StreamErrorStanza::Clear() { … }

const char* StreamErrorStanza::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* StreamErrorStanza::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t StreamErrorStanza::ByteSizeLong() const { … }

void StreamErrorStanza::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void StreamErrorStanza::MergeFrom(const StreamErrorStanza& from) { … }

void StreamErrorStanza::CopyFrom(const StreamErrorStanza& from) { … }

bool StreamErrorStanza::IsInitialized() const { … }

void StreamErrorStanza::InternalSwap(StreamErrorStanza* other) { … }

std::string StreamErrorStanza::GetTypeName() const { … }


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

class Close::_Internal { … };

Close::Close(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
Close::Close(const Close& from)
  : … { … }

inline void Close::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

Close::~Close() { … }

inline void Close::SharedDtor() { … }

void Close::SetCachedSize(int size) const { … }

void Close::Clear() { … }

const char* Close::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* Close::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t Close::ByteSizeLong() const { … }

void Close::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void Close::MergeFrom(const Close& from) { … }

void Close::CopyFrom(const Close& from) { … }

bool Close::IsInitialized() const { … }

void Close::InternalSwap(Close* other) { … }

std::string Close::GetTypeName() const { … }


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

class Extension::_Internal { … };

Extension::Extension(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
Extension::Extension(const Extension& from)
  : … { … }

inline void Extension::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

Extension::~Extension() { … }

inline void Extension::SharedDtor() { … }

void Extension::SetCachedSize(int size) const { … }

void Extension::Clear() { … }

const char* Extension::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* Extension::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t Extension::RequiredFieldsByteSizeFallback() const { … }
size_t Extension::ByteSizeLong() const { … }

void Extension::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void Extension::MergeFrom(const Extension& from) { … }

void Extension::CopyFrom(const Extension& from) { … }

bool Extension::IsInitialized() const { … }

void Extension::InternalSwap(Extension* other) { … }

std::string Extension::GetTypeName() const { … }


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

class IqStanza::_Internal { … };

const ::mcs_proto::ErrorInfo&
IqStanza::_Internal::error(const IqStanza* msg) { … }
const ::mcs_proto::Extension&
IqStanza::_Internal::extension(const IqStanza* msg) { … }
IqStanza::IqStanza(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
IqStanza::IqStanza(const IqStanza& from)
  : … { … }

inline void IqStanza::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

IqStanza::~IqStanza() { … }

inline void IqStanza::SharedDtor() { … }

void IqStanza::SetCachedSize(int size) const { … }

void IqStanza::Clear() { … }

const char* IqStanza::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* IqStanza::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t IqStanza::RequiredFieldsByteSizeFallback() const { … }
size_t IqStanza::ByteSizeLong() const { … }

void IqStanza::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void IqStanza::MergeFrom(const IqStanza& from) { … }

void IqStanza::CopyFrom(const IqStanza& from) { … }

bool IqStanza::IsInitialized() const { … }

void IqStanza::InternalSwap(IqStanza* other) { … }

std::string IqStanza::GetTypeName() const { … }


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

class AppData::_Internal { … };

AppData::AppData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
AppData::AppData(const AppData& from)
  : … { … }

inline void AppData::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

AppData::~AppData() { … }

inline void AppData::SharedDtor() { … }

void AppData::SetCachedSize(int size) const { … }

void AppData::Clear() { … }

const char* AppData::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* AppData::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t AppData::RequiredFieldsByteSizeFallback() const { … }
size_t AppData::ByteSizeLong() const { … }

void AppData::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void AppData::MergeFrom(const AppData& from) { … }

void AppData::CopyFrom(const AppData& from) { … }

bool AppData::IsInitialized() const { … }

void AppData::InternalSwap(AppData* other) { … }

std::string AppData::GetTypeName() const { … }


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

class DataMessageStanza::_Internal { … };

DataMessageStanza::DataMessageStanza(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
DataMessageStanza::DataMessageStanza(const DataMessageStanza& from)
  : … { … }

inline void DataMessageStanza::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

DataMessageStanza::~DataMessageStanza() { … }

inline void DataMessageStanza::SharedDtor() { … }

void DataMessageStanza::SetCachedSize(int size) const { … }

void DataMessageStanza::Clear() { … }

const char* DataMessageStanza::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* DataMessageStanza::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t DataMessageStanza::RequiredFieldsByteSizeFallback() const { … }
size_t DataMessageStanza::ByteSizeLong() const { … }

void DataMessageStanza::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void DataMessageStanza::MergeFrom(const DataMessageStanza& from) { … }

void DataMessageStanza::CopyFrom(const DataMessageStanza& from) { … }

bool DataMessageStanza::IsInitialized() const { … }

void DataMessageStanza::InternalSwap(DataMessageStanza* other) { … }

std::string DataMessageStanza::GetTypeName() const { … }


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

class StreamAck::_Internal { … };

StreamAck::StreamAck(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
StreamAck::StreamAck(const StreamAck& from)
  : … { … }

inline void StreamAck::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

StreamAck::~StreamAck() { … }

inline void StreamAck::SharedDtor() { … }

void StreamAck::SetCachedSize(int size) const { … }

void StreamAck::Clear() { … }

const char* StreamAck::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* StreamAck::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t StreamAck::ByteSizeLong() const { … }

void StreamAck::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void StreamAck::MergeFrom(const StreamAck& from) { … }

void StreamAck::CopyFrom(const StreamAck& from) { … }

bool StreamAck::IsInitialized() const { … }

void StreamAck::InternalSwap(StreamAck* other) { … }

std::string StreamAck::GetTypeName() const { … }


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

class SelectiveAck::_Internal { … };

SelectiveAck::SelectiveAck(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
SelectiveAck::SelectiveAck(const SelectiveAck& from)
  : … { … }

inline void SelectiveAck::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

SelectiveAck::~SelectiveAck() { … }

inline void SelectiveAck::SharedDtor() { … }

void SelectiveAck::SetCachedSize(int size) const { … }

void SelectiveAck::Clear() { … }

const char* SelectiveAck::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* SelectiveAck::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t SelectiveAck::ByteSizeLong() const { … }

void SelectiveAck::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void SelectiveAck::MergeFrom(const SelectiveAck& from) { … }

void SelectiveAck::CopyFrom(const SelectiveAck& from) { … }

bool SelectiveAck::IsInitialized() const { … }

void SelectiveAck::InternalSwap(SelectiveAck* other) { … }

std::string SelectiveAck::GetTypeName() const { … }


// @@protoc_insertion_point(namespace_scope)
}  // namespace mcs_proto
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::mcs_proto::HeartbeatPing*
Arena::CreateMaybeMessage< ::mcs_proto::HeartbeatPing >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::HeartbeatAck*
Arena::CreateMaybeMessage< ::mcs_proto::HeartbeatAck >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::ErrorInfo*
Arena::CreateMaybeMessage< ::mcs_proto::ErrorInfo >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::Setting*
Arena::CreateMaybeMessage< ::mcs_proto::Setting >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::HeartbeatStat*
Arena::CreateMaybeMessage< ::mcs_proto::HeartbeatStat >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::HeartbeatConfig*
Arena::CreateMaybeMessage< ::mcs_proto::HeartbeatConfig >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::ClientEvent*
Arena::CreateMaybeMessage< ::mcs_proto::ClientEvent >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::LoginRequest*
Arena::CreateMaybeMessage< ::mcs_proto::LoginRequest >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::LoginResponse*
Arena::CreateMaybeMessage< ::mcs_proto::LoginResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::StreamErrorStanza*
Arena::CreateMaybeMessage< ::mcs_proto::StreamErrorStanza >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::Close*
Arena::CreateMaybeMessage< ::mcs_proto::Close >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::Extension*
Arena::CreateMaybeMessage< ::mcs_proto::Extension >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::IqStanza*
Arena::CreateMaybeMessage< ::mcs_proto::IqStanza >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::AppData*
Arena::CreateMaybeMessage< ::mcs_proto::AppData >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::DataMessageStanza*
Arena::CreateMaybeMessage< ::mcs_proto::DataMessageStanza >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::StreamAck*
Arena::CreateMaybeMessage< ::mcs_proto::StreamAck >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::mcs_proto::SelectiveAck*
Arena::CreateMaybeMessage< ::mcs_proto::SelectiveAck >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>