1759 lines
57 KiB
C++
1759 lines
57 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: chatcleaner.proto
|
|
|
|
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
|
|
#include "chatcleaner.pb.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <google/protobuf/stubs/common.h>
|
|
#include <google/protobuf/stubs/once.h>
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/wire_format_lite_inl.h>
|
|
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
|
|
// @@protoc_insertion_point(includes)
|
|
|
|
void protobuf_ShutdownFile_chatcleaner_2eproto() {
|
|
delete CleanerInitMessage::default_instance_;
|
|
delete CleanerInitAckMessage::default_instance_;
|
|
delete CleanerChatRequestMessage::default_instance_;
|
|
delete CleanerChatReplyMessage::default_instance_;
|
|
delete ChatCleanerMessage::default_instance_;
|
|
}
|
|
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
void protobuf_AddDesc_chatcleaner_2eproto_impl() {
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
#else
|
|
void protobuf_AddDesc_chatcleaner_2eproto() {
|
|
static bool already_here = false;
|
|
if (already_here) return;
|
|
already_here = true;
|
|
GOOGLE_PROTOBUF_VERIFY_VERSION;
|
|
|
|
#endif
|
|
CleanerInitMessage::default_instance_ = new CleanerInitMessage();
|
|
CleanerInitAckMessage::default_instance_ = new CleanerInitAckMessage();
|
|
CleanerChatRequestMessage::default_instance_ = new CleanerChatRequestMessage();
|
|
CleanerChatReplyMessage::default_instance_ = new CleanerChatReplyMessage();
|
|
ChatCleanerMessage::default_instance_ = new ChatCleanerMessage();
|
|
CleanerInitMessage::default_instance_->InitAsDefaultInstance();
|
|
CleanerInitAckMessage::default_instance_->InitAsDefaultInstance();
|
|
CleanerChatRequestMessage::default_instance_->InitAsDefaultInstance();
|
|
CleanerChatReplyMessage::default_instance_->InitAsDefaultInstance();
|
|
ChatCleanerMessage::default_instance_->InitAsDefaultInstance();
|
|
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_chatcleaner_2eproto);
|
|
}
|
|
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_chatcleaner_2eproto_once_);
|
|
void protobuf_AddDesc_chatcleaner_2eproto() {
|
|
::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_chatcleaner_2eproto_once_,
|
|
&protobuf_AddDesc_chatcleaner_2eproto_impl);
|
|
}
|
|
#else
|
|
// Force AddDescriptors() to be called at static initialization time.
|
|
struct StaticDescriptorInitializer_chatcleaner_2eproto {
|
|
StaticDescriptorInitializer_chatcleaner_2eproto() {
|
|
protobuf_AddDesc_chatcleaner_2eproto();
|
|
}
|
|
} static_descriptor_initializer_chatcleaner_2eproto_;
|
|
#endif
|
|
bool CleanerChatType_IsValid(int value) {
|
|
switch(value) {
|
|
case 0:
|
|
case 1:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifndef _MSC_VER
|
|
const int CleanerInitMessage::kRequestedVersionFieldNumber;
|
|
const int CleanerInitMessage::kClientSecretFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
CleanerInitMessage::CleanerInitMessage()
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:CleanerInitMessage)
|
|
}
|
|
|
|
void CleanerInitMessage::InitAsDefaultInstance() {
|
|
}
|
|
|
|
CleanerInitMessage::CleanerInitMessage(const CleanerInitMessage& from)
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
// @@protoc_insertion_point(copy_constructor:CleanerInitMessage)
|
|
}
|
|
|
|
void CleanerInitMessage::SharedCtor() {
|
|
::google::protobuf::internal::GetEmptyString();
|
|
_cached_size_ = 0;
|
|
requestedversion_ = 0u;
|
|
clientsecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
CleanerInitMessage::~CleanerInitMessage() {
|
|
// @@protoc_insertion_point(destructor:CleanerInitMessage)
|
|
SharedDtor();
|
|
}
|
|
|
|
void CleanerInitMessage::SharedDtor() {
|
|
if (clientsecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
delete clientsecret_;
|
|
}
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
if (this != &default_instance()) {
|
|
#else
|
|
if (this != default_instance_) {
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void CleanerInitMessage::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const CleanerInitMessage& CleanerInitMessage::default_instance() {
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
protobuf_AddDesc_chatcleaner_2eproto();
|
|
#else
|
|
if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
|
|
#endif
|
|
return *default_instance_;
|
|
}
|
|
|
|
CleanerInitMessage* CleanerInitMessage::default_instance_ = NULL;
|
|
|
|
CleanerInitMessage* CleanerInitMessage::New() const {
|
|
return new CleanerInitMessage;
|
|
}
|
|
|
|
void CleanerInitMessage::Clear() {
|
|
if (_has_bits_[0 / 32] & 3) {
|
|
requestedversion_ = 0u;
|
|
if (has_clientsecret()) {
|
|
if (clientsecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
clientsecret_->clear();
|
|
}
|
|
}
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->clear();
|
|
}
|
|
|
|
bool CleanerInitMessage::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
|
|
::google::protobuf::uint32 tag;
|
|
::google::protobuf::io::StringOutputStream unknown_fields_string(
|
|
mutable_unknown_fields());
|
|
::google::protobuf::io::CodedOutputStream unknown_fields_stream(
|
|
&unknown_fields_string);
|
|
// @@protoc_insertion_point(parse_start:CleanerInitMessage)
|
|
for (;;) {
|
|
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
|
|
tag = p.first;
|
|
if (!p.second) goto handle_unusual;
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required uint32 requestedVersion = 1;
|
|
case 1: {
|
|
if (tag == 8) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &requestedversion_)));
|
|
set_has_requestedversion();
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(18)) goto parse_clientSecret;
|
|
break;
|
|
}
|
|
|
|
// required string clientSecret = 2;
|
|
case 2: {
|
|
if (tag == 18) {
|
|
parse_clientSecret:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_clientsecret()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectAtEnd()) goto success;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_unusual:
|
|
if (tag == 0 ||
|
|
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
goto success;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormatLite::SkipField(
|
|
input, tag, &unknown_fields_stream));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
success:
|
|
// @@protoc_insertion_point(parse_success:CleanerInitMessage)
|
|
return true;
|
|
failure:
|
|
// @@protoc_insertion_point(parse_failure:CleanerInitMessage)
|
|
return false;
|
|
#undef DO_
|
|
}
|
|
|
|
void CleanerInitMessage::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// @@protoc_insertion_point(serialize_start:CleanerInitMessage)
|
|
// required uint32 requestedVersion = 1;
|
|
if (has_requestedversion()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestedversion(), output);
|
|
}
|
|
|
|
// required string clientSecret = 2;
|
|
if (has_clientsecret()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
|
|
2, this->clientsecret(), output);
|
|
}
|
|
|
|
output->WriteRaw(unknown_fields().data(),
|
|
unknown_fields().size());
|
|
// @@protoc_insertion_point(serialize_end:CleanerInitMessage)
|
|
}
|
|
|
|
int CleanerInitMessage::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required uint32 requestedVersion = 1;
|
|
if (has_requestedversion()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->requestedversion());
|
|
}
|
|
|
|
// required string clientSecret = 2;
|
|
if (has_clientsecret()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->clientsecret());
|
|
}
|
|
|
|
}
|
|
total_size += unknown_fields().size();
|
|
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void CleanerInitMessage::CheckTypeAndMergeFrom(
|
|
const ::google::protobuf::MessageLite& from) {
|
|
MergeFrom(*::google::protobuf::down_cast<const CleanerInitMessage*>(&from));
|
|
}
|
|
|
|
void CleanerInitMessage::MergeFrom(const CleanerInitMessage& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_requestedversion()) {
|
|
set_requestedversion(from.requestedversion());
|
|
}
|
|
if (from.has_clientsecret()) {
|
|
set_clientsecret(from.clientsecret());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->append(from.unknown_fields());
|
|
}
|
|
|
|
void CleanerInitMessage::CopyFrom(const CleanerInitMessage& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool CleanerInitMessage::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CleanerInitMessage::Swap(CleanerInitMessage* other) {
|
|
if (other != this) {
|
|
std::swap(requestedversion_, other->requestedversion_);
|
|
std::swap(clientsecret_, other->clientsecret_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.swap(other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::std::string CleanerInitMessage::GetTypeName() const {
|
|
return "CleanerInitMessage";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifndef _MSC_VER
|
|
const int CleanerInitAckMessage::kServerVersionFieldNumber;
|
|
const int CleanerInitAckMessage::kServerSecretFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
CleanerInitAckMessage::CleanerInitAckMessage()
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:CleanerInitAckMessage)
|
|
}
|
|
|
|
void CleanerInitAckMessage::InitAsDefaultInstance() {
|
|
}
|
|
|
|
CleanerInitAckMessage::CleanerInitAckMessage(const CleanerInitAckMessage& from)
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
// @@protoc_insertion_point(copy_constructor:CleanerInitAckMessage)
|
|
}
|
|
|
|
void CleanerInitAckMessage::SharedCtor() {
|
|
::google::protobuf::internal::GetEmptyString();
|
|
_cached_size_ = 0;
|
|
serverversion_ = 0u;
|
|
serversecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
CleanerInitAckMessage::~CleanerInitAckMessage() {
|
|
// @@protoc_insertion_point(destructor:CleanerInitAckMessage)
|
|
SharedDtor();
|
|
}
|
|
|
|
void CleanerInitAckMessage::SharedDtor() {
|
|
if (serversecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
delete serversecret_;
|
|
}
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
if (this != &default_instance()) {
|
|
#else
|
|
if (this != default_instance_) {
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void CleanerInitAckMessage::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const CleanerInitAckMessage& CleanerInitAckMessage::default_instance() {
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
protobuf_AddDesc_chatcleaner_2eproto();
|
|
#else
|
|
if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
|
|
#endif
|
|
return *default_instance_;
|
|
}
|
|
|
|
CleanerInitAckMessage* CleanerInitAckMessage::default_instance_ = NULL;
|
|
|
|
CleanerInitAckMessage* CleanerInitAckMessage::New() const {
|
|
return new CleanerInitAckMessage;
|
|
}
|
|
|
|
void CleanerInitAckMessage::Clear() {
|
|
if (_has_bits_[0 / 32] & 3) {
|
|
serverversion_ = 0u;
|
|
if (has_serversecret()) {
|
|
if (serversecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
serversecret_->clear();
|
|
}
|
|
}
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->clear();
|
|
}
|
|
|
|
bool CleanerInitAckMessage::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
|
|
::google::protobuf::uint32 tag;
|
|
::google::protobuf::io::StringOutputStream unknown_fields_string(
|
|
mutable_unknown_fields());
|
|
::google::protobuf::io::CodedOutputStream unknown_fields_stream(
|
|
&unknown_fields_string);
|
|
// @@protoc_insertion_point(parse_start:CleanerInitAckMessage)
|
|
for (;;) {
|
|
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
|
|
tag = p.first;
|
|
if (!p.second) goto handle_unusual;
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required uint32 serverVersion = 1;
|
|
case 1: {
|
|
if (tag == 8) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &serverversion_)));
|
|
set_has_serverversion();
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(18)) goto parse_serverSecret;
|
|
break;
|
|
}
|
|
|
|
// required string serverSecret = 2;
|
|
case 2: {
|
|
if (tag == 18) {
|
|
parse_serverSecret:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_serversecret()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectAtEnd()) goto success;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_unusual:
|
|
if (tag == 0 ||
|
|
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
goto success;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormatLite::SkipField(
|
|
input, tag, &unknown_fields_stream));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
success:
|
|
// @@protoc_insertion_point(parse_success:CleanerInitAckMessage)
|
|
return true;
|
|
failure:
|
|
// @@protoc_insertion_point(parse_failure:CleanerInitAckMessage)
|
|
return false;
|
|
#undef DO_
|
|
}
|
|
|
|
void CleanerInitAckMessage::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// @@protoc_insertion_point(serialize_start:CleanerInitAckMessage)
|
|
// required uint32 serverVersion = 1;
|
|
if (has_serverversion()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->serverversion(), output);
|
|
}
|
|
|
|
// required string serverSecret = 2;
|
|
if (has_serversecret()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
|
|
2, this->serversecret(), output);
|
|
}
|
|
|
|
output->WriteRaw(unknown_fields().data(),
|
|
unknown_fields().size());
|
|
// @@protoc_insertion_point(serialize_end:CleanerInitAckMessage)
|
|
}
|
|
|
|
int CleanerInitAckMessage::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required uint32 serverVersion = 1;
|
|
if (has_serverversion()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->serverversion());
|
|
}
|
|
|
|
// required string serverSecret = 2;
|
|
if (has_serversecret()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->serversecret());
|
|
}
|
|
|
|
}
|
|
total_size += unknown_fields().size();
|
|
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void CleanerInitAckMessage::CheckTypeAndMergeFrom(
|
|
const ::google::protobuf::MessageLite& from) {
|
|
MergeFrom(*::google::protobuf::down_cast<const CleanerInitAckMessage*>(&from));
|
|
}
|
|
|
|
void CleanerInitAckMessage::MergeFrom(const CleanerInitAckMessage& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_serverversion()) {
|
|
set_serverversion(from.serverversion());
|
|
}
|
|
if (from.has_serversecret()) {
|
|
set_serversecret(from.serversecret());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->append(from.unknown_fields());
|
|
}
|
|
|
|
void CleanerInitAckMessage::CopyFrom(const CleanerInitAckMessage& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool CleanerInitAckMessage::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CleanerInitAckMessage::Swap(CleanerInitAckMessage* other) {
|
|
if (other != this) {
|
|
std::swap(serverversion_, other->serverversion_);
|
|
std::swap(serversecret_, other->serversecret_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.swap(other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::std::string CleanerInitAckMessage::GetTypeName() const {
|
|
return "CleanerInitAckMessage";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifndef _MSC_VER
|
|
const int CleanerChatRequestMessage::kRequestIdFieldNumber;
|
|
const int CleanerChatRequestMessage::kCleanerChatTypeFieldNumber;
|
|
const int CleanerChatRequestMessage::kGameIdFieldNumber;
|
|
const int CleanerChatRequestMessage::kPlayerIdFieldNumber;
|
|
const int CleanerChatRequestMessage::kPlayerNameFieldNumber;
|
|
const int CleanerChatRequestMessage::kChatMessageFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
CleanerChatRequestMessage::CleanerChatRequestMessage()
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:CleanerChatRequestMessage)
|
|
}
|
|
|
|
void CleanerChatRequestMessage::InitAsDefaultInstance() {
|
|
}
|
|
|
|
CleanerChatRequestMessage::CleanerChatRequestMessage(const CleanerChatRequestMessage& from)
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
// @@protoc_insertion_point(copy_constructor:CleanerChatRequestMessage)
|
|
}
|
|
|
|
void CleanerChatRequestMessage::SharedCtor() {
|
|
::google::protobuf::internal::GetEmptyString();
|
|
_cached_size_ = 0;
|
|
requestid_ = 0u;
|
|
cleanerchattype_ = 0;
|
|
gameid_ = 0u;
|
|
playerid_ = 0u;
|
|
playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
chatmessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
CleanerChatRequestMessage::~CleanerChatRequestMessage() {
|
|
// @@protoc_insertion_point(destructor:CleanerChatRequestMessage)
|
|
SharedDtor();
|
|
}
|
|
|
|
void CleanerChatRequestMessage::SharedDtor() {
|
|
if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
delete playername_;
|
|
}
|
|
if (chatmessage_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
delete chatmessage_;
|
|
}
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
if (this != &default_instance()) {
|
|
#else
|
|
if (this != default_instance_) {
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void CleanerChatRequestMessage::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const CleanerChatRequestMessage& CleanerChatRequestMessage::default_instance() {
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
protobuf_AddDesc_chatcleaner_2eproto();
|
|
#else
|
|
if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
|
|
#endif
|
|
return *default_instance_;
|
|
}
|
|
|
|
CleanerChatRequestMessage* CleanerChatRequestMessage::default_instance_ = NULL;
|
|
|
|
CleanerChatRequestMessage* CleanerChatRequestMessage::New() const {
|
|
return new CleanerChatRequestMessage;
|
|
}
|
|
|
|
void CleanerChatRequestMessage::Clear() {
|
|
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
|
|
&reinterpret_cast<CleanerChatRequestMessage*>(16)->f) - \
|
|
reinterpret_cast<char*>(16))
|
|
|
|
#define ZR_(first, last) do { \
|
|
size_t f = OFFSET_OF_FIELD_(first); \
|
|
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
|
|
::memset(&first, 0, n); \
|
|
} while (0)
|
|
|
|
if (_has_bits_[0 / 32] & 63) {
|
|
ZR_(requestid_, playerid_);
|
|
if (has_playername()) {
|
|
if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
playername_->clear();
|
|
}
|
|
}
|
|
if (has_chatmessage()) {
|
|
if (chatmessage_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
chatmessage_->clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef OFFSET_OF_FIELD_
|
|
#undef ZR_
|
|
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->clear();
|
|
}
|
|
|
|
bool CleanerChatRequestMessage::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
|
|
::google::protobuf::uint32 tag;
|
|
::google::protobuf::io::StringOutputStream unknown_fields_string(
|
|
mutable_unknown_fields());
|
|
::google::protobuf::io::CodedOutputStream unknown_fields_stream(
|
|
&unknown_fields_string);
|
|
// @@protoc_insertion_point(parse_start:CleanerChatRequestMessage)
|
|
for (;;) {
|
|
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
|
|
tag = p.first;
|
|
if (!p.second) goto handle_unusual;
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required uint32 requestId = 1;
|
|
case 1: {
|
|
if (tag == 8) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &requestid_)));
|
|
set_has_requestid();
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(16)) goto parse_cleanerChatType;
|
|
break;
|
|
}
|
|
|
|
// required .CleanerChatType cleanerChatType = 2;
|
|
case 2: {
|
|
if (tag == 16) {
|
|
parse_cleanerChatType:
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
if (::CleanerChatType_IsValid(value)) {
|
|
set_cleanerchattype(static_cast< ::CleanerChatType >(value));
|
|
} else {
|
|
unknown_fields_stream.WriteVarint32(tag);
|
|
unknown_fields_stream.WriteVarint32(value);
|
|
}
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(24)) goto parse_gameId;
|
|
break;
|
|
}
|
|
|
|
// optional uint32 gameId = 3 [default = 0];
|
|
case 3: {
|
|
if (tag == 24) {
|
|
parse_gameId:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &gameid_)));
|
|
set_has_gameid();
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(32)) goto parse_playerId;
|
|
break;
|
|
}
|
|
|
|
// required uint32 playerId = 4;
|
|
case 4: {
|
|
if (tag == 32) {
|
|
parse_playerId:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &playerid_)));
|
|
set_has_playerid();
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(42)) goto parse_playerName;
|
|
break;
|
|
}
|
|
|
|
// required string playerName = 5;
|
|
case 5: {
|
|
if (tag == 42) {
|
|
parse_playerName:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_playername()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(50)) goto parse_chatMessage;
|
|
break;
|
|
}
|
|
|
|
// required string chatMessage = 6;
|
|
case 6: {
|
|
if (tag == 50) {
|
|
parse_chatMessage:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_chatmessage()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectAtEnd()) goto success;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_unusual:
|
|
if (tag == 0 ||
|
|
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
goto success;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormatLite::SkipField(
|
|
input, tag, &unknown_fields_stream));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
success:
|
|
// @@protoc_insertion_point(parse_success:CleanerChatRequestMessage)
|
|
return true;
|
|
failure:
|
|
// @@protoc_insertion_point(parse_failure:CleanerChatRequestMessage)
|
|
return false;
|
|
#undef DO_
|
|
}
|
|
|
|
void CleanerChatRequestMessage::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// @@protoc_insertion_point(serialize_start:CleanerChatRequestMessage)
|
|
// required uint32 requestId = 1;
|
|
if (has_requestid()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
|
|
}
|
|
|
|
// required .CleanerChatType cleanerChatType = 2;
|
|
if (has_cleanerchattype()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
2, this->cleanerchattype(), output);
|
|
}
|
|
|
|
// optional uint32 gameId = 3 [default = 0];
|
|
if (has_gameid()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->gameid(), output);
|
|
}
|
|
|
|
// required uint32 playerId = 4;
|
|
if (has_playerid()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->playerid(), output);
|
|
}
|
|
|
|
// required string playerName = 5;
|
|
if (has_playername()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
|
|
5, this->playername(), output);
|
|
}
|
|
|
|
// required string chatMessage = 6;
|
|
if (has_chatmessage()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
|
|
6, this->chatmessage(), output);
|
|
}
|
|
|
|
output->WriteRaw(unknown_fields().data(),
|
|
unknown_fields().size());
|
|
// @@protoc_insertion_point(serialize_end:CleanerChatRequestMessage)
|
|
}
|
|
|
|
int CleanerChatRequestMessage::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required uint32 requestId = 1;
|
|
if (has_requestid()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->requestid());
|
|
}
|
|
|
|
// required .CleanerChatType cleanerChatType = 2;
|
|
if (has_cleanerchattype()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->cleanerchattype());
|
|
}
|
|
|
|
// optional uint32 gameId = 3 [default = 0];
|
|
if (has_gameid()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->gameid());
|
|
}
|
|
|
|
// required uint32 playerId = 4;
|
|
if (has_playerid()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->playerid());
|
|
}
|
|
|
|
// required string playerName = 5;
|
|
if (has_playername()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->playername());
|
|
}
|
|
|
|
// required string chatMessage = 6;
|
|
if (has_chatmessage()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->chatmessage());
|
|
}
|
|
|
|
}
|
|
total_size += unknown_fields().size();
|
|
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void CleanerChatRequestMessage::CheckTypeAndMergeFrom(
|
|
const ::google::protobuf::MessageLite& from) {
|
|
MergeFrom(*::google::protobuf::down_cast<const CleanerChatRequestMessage*>(&from));
|
|
}
|
|
|
|
void CleanerChatRequestMessage::MergeFrom(const CleanerChatRequestMessage& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_requestid()) {
|
|
set_requestid(from.requestid());
|
|
}
|
|
if (from.has_cleanerchattype()) {
|
|
set_cleanerchattype(from.cleanerchattype());
|
|
}
|
|
if (from.has_gameid()) {
|
|
set_gameid(from.gameid());
|
|
}
|
|
if (from.has_playerid()) {
|
|
set_playerid(from.playerid());
|
|
}
|
|
if (from.has_playername()) {
|
|
set_playername(from.playername());
|
|
}
|
|
if (from.has_chatmessage()) {
|
|
set_chatmessage(from.chatmessage());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->append(from.unknown_fields());
|
|
}
|
|
|
|
void CleanerChatRequestMessage::CopyFrom(const CleanerChatRequestMessage& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool CleanerChatRequestMessage::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x0000003b) != 0x0000003b) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CleanerChatRequestMessage::Swap(CleanerChatRequestMessage* other) {
|
|
if (other != this) {
|
|
std::swap(requestid_, other->requestid_);
|
|
std::swap(cleanerchattype_, other->cleanerchattype_);
|
|
std::swap(gameid_, other->gameid_);
|
|
std::swap(playerid_, other->playerid_);
|
|
std::swap(playername_, other->playername_);
|
|
std::swap(chatmessage_, other->chatmessage_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.swap(other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::std::string CleanerChatRequestMessage::GetTypeName() const {
|
|
return "CleanerChatRequestMessage";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
bool CleanerChatReplyMessage_CleanerActionType_IsValid(int value) {
|
|
switch(value) {
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#ifndef _MSC_VER
|
|
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionNone;
|
|
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionWarning;
|
|
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionKick;
|
|
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionBan;
|
|
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleanerActionMute;
|
|
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::CleanerActionType_MIN;
|
|
const CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::CleanerActionType_MAX;
|
|
const int CleanerChatReplyMessage::CleanerActionType_ARRAYSIZE;
|
|
#endif // _MSC_VER
|
|
#ifndef _MSC_VER
|
|
const int CleanerChatReplyMessage::kRequestIdFieldNumber;
|
|
const int CleanerChatReplyMessage::kCleanerChatTypeFieldNumber;
|
|
const int CleanerChatReplyMessage::kGameIdFieldNumber;
|
|
const int CleanerChatReplyMessage::kPlayerIdFieldNumber;
|
|
const int CleanerChatReplyMessage::kCleanerActionTypeFieldNumber;
|
|
const int CleanerChatReplyMessage::kCleanerTextFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
CleanerChatReplyMessage::CleanerChatReplyMessage()
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:CleanerChatReplyMessage)
|
|
}
|
|
|
|
void CleanerChatReplyMessage::InitAsDefaultInstance() {
|
|
}
|
|
|
|
CleanerChatReplyMessage::CleanerChatReplyMessage(const CleanerChatReplyMessage& from)
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
// @@protoc_insertion_point(copy_constructor:CleanerChatReplyMessage)
|
|
}
|
|
|
|
void CleanerChatReplyMessage::SharedCtor() {
|
|
::google::protobuf::internal::GetEmptyString();
|
|
_cached_size_ = 0;
|
|
requestid_ = 0u;
|
|
cleanerchattype_ = 0;
|
|
gameid_ = 0u;
|
|
playerid_ = 0u;
|
|
cleaneractiontype_ = 0;
|
|
cleanertext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
CleanerChatReplyMessage::~CleanerChatReplyMessage() {
|
|
// @@protoc_insertion_point(destructor:CleanerChatReplyMessage)
|
|
SharedDtor();
|
|
}
|
|
|
|
void CleanerChatReplyMessage::SharedDtor() {
|
|
if (cleanertext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
delete cleanertext_;
|
|
}
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
if (this != &default_instance()) {
|
|
#else
|
|
if (this != default_instance_) {
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void CleanerChatReplyMessage::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const CleanerChatReplyMessage& CleanerChatReplyMessage::default_instance() {
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
protobuf_AddDesc_chatcleaner_2eproto();
|
|
#else
|
|
if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
|
|
#endif
|
|
return *default_instance_;
|
|
}
|
|
|
|
CleanerChatReplyMessage* CleanerChatReplyMessage::default_instance_ = NULL;
|
|
|
|
CleanerChatReplyMessage* CleanerChatReplyMessage::New() const {
|
|
return new CleanerChatReplyMessage;
|
|
}
|
|
|
|
void CleanerChatReplyMessage::Clear() {
|
|
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>( \
|
|
&reinterpret_cast<CleanerChatReplyMessage*>(16)->f) - \
|
|
reinterpret_cast<char*>(16))
|
|
|
|
#define ZR_(first, last) do { \
|
|
size_t f = OFFSET_OF_FIELD_(first); \
|
|
size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last); \
|
|
::memset(&first, 0, n); \
|
|
} while (0)
|
|
|
|
if (_has_bits_[0 / 32] & 63) {
|
|
ZR_(requestid_, playerid_);
|
|
cleaneractiontype_ = 0;
|
|
if (has_cleanertext()) {
|
|
if (cleanertext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
|
|
cleanertext_->clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef OFFSET_OF_FIELD_
|
|
#undef ZR_
|
|
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->clear();
|
|
}
|
|
|
|
bool CleanerChatReplyMessage::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
|
|
::google::protobuf::uint32 tag;
|
|
::google::protobuf::io::StringOutputStream unknown_fields_string(
|
|
mutable_unknown_fields());
|
|
::google::protobuf::io::CodedOutputStream unknown_fields_stream(
|
|
&unknown_fields_string);
|
|
// @@protoc_insertion_point(parse_start:CleanerChatReplyMessage)
|
|
for (;;) {
|
|
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
|
|
tag = p.first;
|
|
if (!p.second) goto handle_unusual;
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required uint32 requestId = 1;
|
|
case 1: {
|
|
if (tag == 8) {
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &requestid_)));
|
|
set_has_requestid();
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(16)) goto parse_cleanerChatType;
|
|
break;
|
|
}
|
|
|
|
// required .CleanerChatType cleanerChatType = 2;
|
|
case 2: {
|
|
if (tag == 16) {
|
|
parse_cleanerChatType:
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
if (::CleanerChatType_IsValid(value)) {
|
|
set_cleanerchattype(static_cast< ::CleanerChatType >(value));
|
|
} else {
|
|
unknown_fields_stream.WriteVarint32(tag);
|
|
unknown_fields_stream.WriteVarint32(value);
|
|
}
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(24)) goto parse_gameId;
|
|
break;
|
|
}
|
|
|
|
// optional uint32 gameId = 3 [default = 0];
|
|
case 3: {
|
|
if (tag == 24) {
|
|
parse_gameId:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &gameid_)));
|
|
set_has_gameid();
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(32)) goto parse_playerId;
|
|
break;
|
|
}
|
|
|
|
// required uint32 playerId = 4;
|
|
case 4: {
|
|
if (tag == 32) {
|
|
parse_playerId:
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
|
|
input, &playerid_)));
|
|
set_has_playerid();
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(40)) goto parse_cleanerActionType;
|
|
break;
|
|
}
|
|
|
|
// required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
|
|
case 5: {
|
|
if (tag == 40) {
|
|
parse_cleanerActionType:
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
if (::CleanerChatReplyMessage_CleanerActionType_IsValid(value)) {
|
|
set_cleaneractiontype(static_cast< ::CleanerChatReplyMessage_CleanerActionType >(value));
|
|
} else {
|
|
unknown_fields_stream.WriteVarint32(tag);
|
|
unknown_fields_stream.WriteVarint32(value);
|
|
}
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(50)) goto parse_cleanerText;
|
|
break;
|
|
}
|
|
|
|
// optional string cleanerText = 6 [default = ""];
|
|
case 6: {
|
|
if (tag == 50) {
|
|
parse_cleanerText:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
|
|
input, this->mutable_cleanertext()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectAtEnd()) goto success;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_unusual:
|
|
if (tag == 0 ||
|
|
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
goto success;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormatLite::SkipField(
|
|
input, tag, &unknown_fields_stream));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
success:
|
|
// @@protoc_insertion_point(parse_success:CleanerChatReplyMessage)
|
|
return true;
|
|
failure:
|
|
// @@protoc_insertion_point(parse_failure:CleanerChatReplyMessage)
|
|
return false;
|
|
#undef DO_
|
|
}
|
|
|
|
void CleanerChatReplyMessage::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// @@protoc_insertion_point(serialize_start:CleanerChatReplyMessage)
|
|
// required uint32 requestId = 1;
|
|
if (has_requestid()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->requestid(), output);
|
|
}
|
|
|
|
// required .CleanerChatType cleanerChatType = 2;
|
|
if (has_cleanerchattype()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
2, this->cleanerchattype(), output);
|
|
}
|
|
|
|
// optional uint32 gameId = 3 [default = 0];
|
|
if (has_gameid()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->gameid(), output);
|
|
}
|
|
|
|
// required uint32 playerId = 4;
|
|
if (has_playerid()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->playerid(), output);
|
|
}
|
|
|
|
// required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
|
|
if (has_cleaneractiontype()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
5, this->cleaneractiontype(), output);
|
|
}
|
|
|
|
// optional string cleanerText = 6 [default = ""];
|
|
if (has_cleanertext()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
|
|
6, this->cleanertext(), output);
|
|
}
|
|
|
|
output->WriteRaw(unknown_fields().data(),
|
|
unknown_fields().size());
|
|
// @@protoc_insertion_point(serialize_end:CleanerChatReplyMessage)
|
|
}
|
|
|
|
int CleanerChatReplyMessage::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required uint32 requestId = 1;
|
|
if (has_requestid()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->requestid());
|
|
}
|
|
|
|
// required .CleanerChatType cleanerChatType = 2;
|
|
if (has_cleanerchattype()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->cleanerchattype());
|
|
}
|
|
|
|
// optional uint32 gameId = 3 [default = 0];
|
|
if (has_gameid()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->gameid());
|
|
}
|
|
|
|
// required uint32 playerId = 4;
|
|
if (has_playerid()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::UInt32Size(
|
|
this->playerid());
|
|
}
|
|
|
|
// required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
|
|
if (has_cleaneractiontype()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->cleaneractiontype());
|
|
}
|
|
|
|
// optional string cleanerText = 6 [default = ""];
|
|
if (has_cleanertext()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::StringSize(
|
|
this->cleanertext());
|
|
}
|
|
|
|
}
|
|
total_size += unknown_fields().size();
|
|
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void CleanerChatReplyMessage::CheckTypeAndMergeFrom(
|
|
const ::google::protobuf::MessageLite& from) {
|
|
MergeFrom(*::google::protobuf::down_cast<const CleanerChatReplyMessage*>(&from));
|
|
}
|
|
|
|
void CleanerChatReplyMessage::MergeFrom(const CleanerChatReplyMessage& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_requestid()) {
|
|
set_requestid(from.requestid());
|
|
}
|
|
if (from.has_cleanerchattype()) {
|
|
set_cleanerchattype(from.cleanerchattype());
|
|
}
|
|
if (from.has_gameid()) {
|
|
set_gameid(from.gameid());
|
|
}
|
|
if (from.has_playerid()) {
|
|
set_playerid(from.playerid());
|
|
}
|
|
if (from.has_cleaneractiontype()) {
|
|
set_cleaneractiontype(from.cleaneractiontype());
|
|
}
|
|
if (from.has_cleanertext()) {
|
|
set_cleanertext(from.cleanertext());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->append(from.unknown_fields());
|
|
}
|
|
|
|
void CleanerChatReplyMessage::CopyFrom(const CleanerChatReplyMessage& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool CleanerChatReplyMessage::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x0000001b) != 0x0000001b) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void CleanerChatReplyMessage::Swap(CleanerChatReplyMessage* other) {
|
|
if (other != this) {
|
|
std::swap(requestid_, other->requestid_);
|
|
std::swap(cleanerchattype_, other->cleanerchattype_);
|
|
std::swap(gameid_, other->gameid_);
|
|
std::swap(playerid_, other->playerid_);
|
|
std::swap(cleaneractiontype_, other->cleaneractiontype_);
|
|
std::swap(cleanertext_, other->cleanertext_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.swap(other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::std::string CleanerChatReplyMessage::GetTypeName() const {
|
|
return "CleanerChatReplyMessage";
|
|
}
|
|
|
|
|
|
// ===================================================================
|
|
|
|
bool ChatCleanerMessage_ChatCleanerMessageType_IsValid(int value) {
|
|
switch(value) {
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#ifndef _MSC_VER
|
|
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerInitMessage;
|
|
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerInitAckMessage;
|
|
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerChatRequestMessage;
|
|
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::Type_CleanerChatReplyMessage;
|
|
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::ChatCleanerMessageType_MIN;
|
|
const ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::ChatCleanerMessageType_MAX;
|
|
const int ChatCleanerMessage::ChatCleanerMessageType_ARRAYSIZE;
|
|
#endif // _MSC_VER
|
|
#ifndef _MSC_VER
|
|
const int ChatCleanerMessage::kMessageTypeFieldNumber;
|
|
const int ChatCleanerMessage::kCleanerInitMessageFieldNumber;
|
|
const int ChatCleanerMessage::kCleanerInitAckMessageFieldNumber;
|
|
const int ChatCleanerMessage::kCleanerChatRequestMessageFieldNumber;
|
|
const int ChatCleanerMessage::kCleanerChatReplyMessageFieldNumber;
|
|
#endif // !_MSC_VER
|
|
|
|
ChatCleanerMessage::ChatCleanerMessage()
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
// @@protoc_insertion_point(constructor:ChatCleanerMessage)
|
|
}
|
|
|
|
void ChatCleanerMessage::InitAsDefaultInstance() {
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
cleanerinitmessage_ = const_cast< ::CleanerInitMessage*>(
|
|
::CleanerInitMessage::internal_default_instance());
|
|
#else
|
|
cleanerinitmessage_ = const_cast< ::CleanerInitMessage*>(&::CleanerInitMessage::default_instance());
|
|
#endif
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
cleanerinitackmessage_ = const_cast< ::CleanerInitAckMessage*>(
|
|
::CleanerInitAckMessage::internal_default_instance());
|
|
#else
|
|
cleanerinitackmessage_ = const_cast< ::CleanerInitAckMessage*>(&::CleanerInitAckMessage::default_instance());
|
|
#endif
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
cleanerchatrequestmessage_ = const_cast< ::CleanerChatRequestMessage*>(
|
|
::CleanerChatRequestMessage::internal_default_instance());
|
|
#else
|
|
cleanerchatrequestmessage_ = const_cast< ::CleanerChatRequestMessage*>(&::CleanerChatRequestMessage::default_instance());
|
|
#endif
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
cleanerchatreplymessage_ = const_cast< ::CleanerChatReplyMessage*>(
|
|
::CleanerChatReplyMessage::internal_default_instance());
|
|
#else
|
|
cleanerchatreplymessage_ = const_cast< ::CleanerChatReplyMessage*>(&::CleanerChatReplyMessage::default_instance());
|
|
#endif
|
|
}
|
|
|
|
ChatCleanerMessage::ChatCleanerMessage(const ChatCleanerMessage& from)
|
|
: ::google::protobuf::MessageLite() {
|
|
SharedCtor();
|
|
MergeFrom(from);
|
|
// @@protoc_insertion_point(copy_constructor:ChatCleanerMessage)
|
|
}
|
|
|
|
void ChatCleanerMessage::SharedCtor() {
|
|
_cached_size_ = 0;
|
|
messagetype_ = 1;
|
|
cleanerinitmessage_ = NULL;
|
|
cleanerinitackmessage_ = NULL;
|
|
cleanerchatrequestmessage_ = NULL;
|
|
cleanerchatreplymessage_ = NULL;
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
}
|
|
|
|
ChatCleanerMessage::~ChatCleanerMessage() {
|
|
// @@protoc_insertion_point(destructor:ChatCleanerMessage)
|
|
SharedDtor();
|
|
}
|
|
|
|
void ChatCleanerMessage::SharedDtor() {
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
if (this != &default_instance()) {
|
|
#else
|
|
if (this != default_instance_) {
|
|
#endif
|
|
delete cleanerinitmessage_;
|
|
delete cleanerinitackmessage_;
|
|
delete cleanerchatrequestmessage_;
|
|
delete cleanerchatreplymessage_;
|
|
}
|
|
}
|
|
|
|
void ChatCleanerMessage::SetCachedSize(int size) const {
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
}
|
|
const ChatCleanerMessage& ChatCleanerMessage::default_instance() {
|
|
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
|
|
protobuf_AddDesc_chatcleaner_2eproto();
|
|
#else
|
|
if (default_instance_ == NULL) protobuf_AddDesc_chatcleaner_2eproto();
|
|
#endif
|
|
return *default_instance_;
|
|
}
|
|
|
|
ChatCleanerMessage* ChatCleanerMessage::default_instance_ = NULL;
|
|
|
|
ChatCleanerMessage* ChatCleanerMessage::New() const {
|
|
return new ChatCleanerMessage;
|
|
}
|
|
|
|
void ChatCleanerMessage::Clear() {
|
|
if (_has_bits_[0 / 32] & 31) {
|
|
messagetype_ = 1;
|
|
if (has_cleanerinitmessage()) {
|
|
if (cleanerinitmessage_ != NULL) cleanerinitmessage_->::CleanerInitMessage::Clear();
|
|
}
|
|
if (has_cleanerinitackmessage()) {
|
|
if (cleanerinitackmessage_ != NULL) cleanerinitackmessage_->::CleanerInitAckMessage::Clear();
|
|
}
|
|
if (has_cleanerchatrequestmessage()) {
|
|
if (cleanerchatrequestmessage_ != NULL) cleanerchatrequestmessage_->::CleanerChatRequestMessage::Clear();
|
|
}
|
|
if (has_cleanerchatreplymessage()) {
|
|
if (cleanerchatreplymessage_ != NULL) cleanerchatreplymessage_->::CleanerChatReplyMessage::Clear();
|
|
}
|
|
}
|
|
::memset(_has_bits_, 0, sizeof(_has_bits_));
|
|
mutable_unknown_fields()->clear();
|
|
}
|
|
|
|
bool ChatCleanerMessage::MergePartialFromCodedStream(
|
|
::google::protobuf::io::CodedInputStream* input) {
|
|
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
|
|
::google::protobuf::uint32 tag;
|
|
::google::protobuf::io::StringOutputStream unknown_fields_string(
|
|
mutable_unknown_fields());
|
|
::google::protobuf::io::CodedOutputStream unknown_fields_stream(
|
|
&unknown_fields_string);
|
|
// @@protoc_insertion_point(parse_start:ChatCleanerMessage)
|
|
for (;;) {
|
|
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
|
|
tag = p.first;
|
|
if (!p.second) goto handle_unusual;
|
|
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
|
|
// required .ChatCleanerMessage.ChatCleanerMessageType messageType = 1;
|
|
case 1: {
|
|
if (tag == 8) {
|
|
int value;
|
|
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
|
|
int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
|
|
input, &value)));
|
|
if (::ChatCleanerMessage_ChatCleanerMessageType_IsValid(value)) {
|
|
set_messagetype(static_cast< ::ChatCleanerMessage_ChatCleanerMessageType >(value));
|
|
} else {
|
|
unknown_fields_stream.WriteVarint32(tag);
|
|
unknown_fields_stream.WriteVarint32(value);
|
|
}
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(18)) goto parse_cleanerInitMessage;
|
|
break;
|
|
}
|
|
|
|
// optional .CleanerInitMessage cleanerInitMessage = 2;
|
|
case 2: {
|
|
if (tag == 18) {
|
|
parse_cleanerInitMessage:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_cleanerinitmessage()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(26)) goto parse_cleanerInitAckMessage;
|
|
break;
|
|
}
|
|
|
|
// optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
|
|
case 3: {
|
|
if (tag == 26) {
|
|
parse_cleanerInitAckMessage:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_cleanerinitackmessage()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(34)) goto parse_cleanerChatRequestMessage;
|
|
break;
|
|
}
|
|
|
|
// optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
|
|
case 4: {
|
|
if (tag == 34) {
|
|
parse_cleanerChatRequestMessage:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_cleanerchatrequestmessage()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectTag(42)) goto parse_cleanerChatReplyMessage;
|
|
break;
|
|
}
|
|
|
|
// optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
|
|
case 5: {
|
|
if (tag == 42) {
|
|
parse_cleanerChatReplyMessage:
|
|
DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
|
|
input, mutable_cleanerchatreplymessage()));
|
|
} else {
|
|
goto handle_unusual;
|
|
}
|
|
if (input->ExpectAtEnd()) goto success;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
handle_unusual:
|
|
if (tag == 0 ||
|
|
::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
|
|
::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
|
|
goto success;
|
|
}
|
|
DO_(::google::protobuf::internal::WireFormatLite::SkipField(
|
|
input, tag, &unknown_fields_stream));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
success:
|
|
// @@protoc_insertion_point(parse_success:ChatCleanerMessage)
|
|
return true;
|
|
failure:
|
|
// @@protoc_insertion_point(parse_failure:ChatCleanerMessage)
|
|
return false;
|
|
#undef DO_
|
|
}
|
|
|
|
void ChatCleanerMessage::SerializeWithCachedSizes(
|
|
::google::protobuf::io::CodedOutputStream* output) const {
|
|
// @@protoc_insertion_point(serialize_start:ChatCleanerMessage)
|
|
// required .ChatCleanerMessage.ChatCleanerMessageType messageType = 1;
|
|
if (has_messagetype()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteEnum(
|
|
1, this->messagetype(), output);
|
|
}
|
|
|
|
// optional .CleanerInitMessage cleanerInitMessage = 2;
|
|
if (has_cleanerinitmessage()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessage(
|
|
2, this->cleanerinitmessage(), output);
|
|
}
|
|
|
|
// optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
|
|
if (has_cleanerinitackmessage()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessage(
|
|
3, this->cleanerinitackmessage(), output);
|
|
}
|
|
|
|
// optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
|
|
if (has_cleanerchatrequestmessage()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessage(
|
|
4, this->cleanerchatrequestmessage(), output);
|
|
}
|
|
|
|
// optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
|
|
if (has_cleanerchatreplymessage()) {
|
|
::google::protobuf::internal::WireFormatLite::WriteMessage(
|
|
5, this->cleanerchatreplymessage(), output);
|
|
}
|
|
|
|
output->WriteRaw(unknown_fields().data(),
|
|
unknown_fields().size());
|
|
// @@protoc_insertion_point(serialize_end:ChatCleanerMessage)
|
|
}
|
|
|
|
int ChatCleanerMessage::ByteSize() const {
|
|
int total_size = 0;
|
|
|
|
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
// required .ChatCleanerMessage.ChatCleanerMessageType messageType = 1;
|
|
if (has_messagetype()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::EnumSize(this->messagetype());
|
|
}
|
|
|
|
// optional .CleanerInitMessage cleanerInitMessage = 2;
|
|
if (has_cleanerinitmessage()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->cleanerinitmessage());
|
|
}
|
|
|
|
// optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
|
|
if (has_cleanerinitackmessage()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->cleanerinitackmessage());
|
|
}
|
|
|
|
// optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
|
|
if (has_cleanerchatrequestmessage()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->cleanerchatrequestmessage());
|
|
}
|
|
|
|
// optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
|
|
if (has_cleanerchatreplymessage()) {
|
|
total_size += 1 +
|
|
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
|
|
this->cleanerchatreplymessage());
|
|
}
|
|
|
|
}
|
|
total_size += unknown_fields().size();
|
|
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
|
|
_cached_size_ = total_size;
|
|
GOOGLE_SAFE_CONCURRENT_WRITES_END();
|
|
return total_size;
|
|
}
|
|
|
|
void ChatCleanerMessage::CheckTypeAndMergeFrom(
|
|
const ::google::protobuf::MessageLite& from) {
|
|
MergeFrom(*::google::protobuf::down_cast<const ChatCleanerMessage*>(&from));
|
|
}
|
|
|
|
void ChatCleanerMessage::MergeFrom(const ChatCleanerMessage& from) {
|
|
GOOGLE_CHECK_NE(&from, this);
|
|
if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
|
|
if (from.has_messagetype()) {
|
|
set_messagetype(from.messagetype());
|
|
}
|
|
if (from.has_cleanerinitmessage()) {
|
|
mutable_cleanerinitmessage()->::CleanerInitMessage::MergeFrom(from.cleanerinitmessage());
|
|
}
|
|
if (from.has_cleanerinitackmessage()) {
|
|
mutable_cleanerinitackmessage()->::CleanerInitAckMessage::MergeFrom(from.cleanerinitackmessage());
|
|
}
|
|
if (from.has_cleanerchatrequestmessage()) {
|
|
mutable_cleanerchatrequestmessage()->::CleanerChatRequestMessage::MergeFrom(from.cleanerchatrequestmessage());
|
|
}
|
|
if (from.has_cleanerchatreplymessage()) {
|
|
mutable_cleanerchatreplymessage()->::CleanerChatReplyMessage::MergeFrom(from.cleanerchatreplymessage());
|
|
}
|
|
}
|
|
mutable_unknown_fields()->append(from.unknown_fields());
|
|
}
|
|
|
|
void ChatCleanerMessage::CopyFrom(const ChatCleanerMessage& from) {
|
|
if (&from == this) return;
|
|
Clear();
|
|
MergeFrom(from);
|
|
}
|
|
|
|
bool ChatCleanerMessage::IsInitialized() const {
|
|
if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
|
|
|
|
if (has_cleanerinitmessage()) {
|
|
if (!this->cleanerinitmessage().IsInitialized()) return false;
|
|
}
|
|
if (has_cleanerinitackmessage()) {
|
|
if (!this->cleanerinitackmessage().IsInitialized()) return false;
|
|
}
|
|
if (has_cleanerchatrequestmessage()) {
|
|
if (!this->cleanerchatrequestmessage().IsInitialized()) return false;
|
|
}
|
|
if (has_cleanerchatreplymessage()) {
|
|
if (!this->cleanerchatreplymessage().IsInitialized()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void ChatCleanerMessage::Swap(ChatCleanerMessage* other) {
|
|
if (other != this) {
|
|
std::swap(messagetype_, other->messagetype_);
|
|
std::swap(cleanerinitmessage_, other->cleanerinitmessage_);
|
|
std::swap(cleanerinitackmessage_, other->cleanerinitackmessage_);
|
|
std::swap(cleanerchatrequestmessage_, other->cleanerchatrequestmessage_);
|
|
std::swap(cleanerchatreplymessage_, other->cleanerchatreplymessage_);
|
|
std::swap(_has_bits_[0], other->_has_bits_[0]);
|
|
_unknown_fields_.swap(other->_unknown_fields_);
|
|
std::swap(_cached_size_, other->_cached_size_);
|
|
}
|
|
}
|
|
|
|
::std::string ChatCleanerMessage::GetTypeName() const {
|
|
return "ChatCleanerMessage";
|
|
}
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
// @@protoc_insertion_point(global_scope)
|