public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_cHE1FieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _cHE1FieldTags[field_ordinal];
}
else
{
ParseUnknownField(input, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
return(this);
}
ParseUnknownField(input, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasId = input.ReadInt32(ref result.id_);
break;
}
case 16: {
result.hasCheSpd = input.ReadInt32(ref result.cheSpd_);
break;
}
case 24: {
result.hasChePassenger = input.ReadInt32(ref result.chePassenger_);
break;
}
case 32: {
result.hasCheCap = input.ReadInt32(ref result.cheCap_);
break;
}
}
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_blobHeaderFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _blobHeaderFieldTags[field_ordinal];
}
else
{
ParseUnknownField(input, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
return(this);
}
ParseUnknownField(input, extensionRegistry, tag, field_name);
break;
}
case 10: {
result.hasType = input.ReadString(ref result.type_);
break;
}
case 18: {
result.hasIndexdata = input.ReadBytes(ref result.indexdata_);
break;
}
case 24: {
result.hasDatasize = input.ReadInt32(ref result.datasize_);
break;
}
}
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_selectionEnvelopeFieldNames, field_name,
global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _selectionEnvelopeFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0:
{
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default:
{
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 10:
{
result.hasEnclosedMessage = input.ReadBytes(ref result.enclosedMessage_);
break;
}
case 16:
{
result.hasSerializerId = input.ReadInt32(ref result.serializerId_);
break;
}
case 26:
{
input.ReadMessageArray(tag, field_name, result.pattern_, global::Selection.DefaultInstance,
extensionRegistry);
break;
}
case 34:
{
result.hasMessageManifest = input.ReadBytes(ref result.messageManifest_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_questRewardFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _questRewardFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasXpGranted = input.ReadInt32(ref result.xpGranted_);
break;
}
case 16: {
result.hasGoldGranted = input.ReadInt32(ref result.goldGranted_);
break;
}
case 26: {
global::D3.Items.Generator.Builder subBuilder = global::D3.Items.Generator.CreateBuilder();
if (result.hasItemGranted)
{
subBuilder.MergeFrom(ItemGranted);
}
input.ReadMessage(subBuilder, extensionRegistry);
ItemGranted = subBuilder.BuildPartial();
break;
}
case 37: {
result.hasSnoQuest = input.ReadSFixed32(ref result.snoQuest_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_searchForPublicGameParamsFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _searchForPublicGameParamsFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasStartTime = input.ReadSInt64(ref result.startTime_);
break;
}
case 16: {
result.hasSecondsToSearch = input.ReadUInt32(ref result.secondsToSearch_);
break;
}
case 26: {
global::D3.OnlineService.GameCreateParams.Builder subBuilder = global::D3.OnlineService.GameCreateParams.CreateBuilder();
if (result.hasGameParams)
{
subBuilder.MergeFrom(GameParams);
}
input.ReadMessage(subBuilder, extensionRegistry);
GameParams = subBuilder.BuildPartial();
break;
}
case 32: {
result.hasRemoveReason = input.ReadInt32(ref result.removeReason_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_s2CFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _s2CFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasRehabType = input.ReadInt32(ref result.rehabType_);
break;
}
case 16: {
result.hasKlType = input.ReadInt32(ref result.klType_);
break;
}
case 26: {
global::Qot_Common.Security.Builder subBuilder = global::Qot_Common.Security.CreateBuilder();
if (result.hasSecurity)
{
subBuilder.MergeFrom(Security);
}
input.ReadMessage(subBuilder, extensionRegistry);
Security = subBuilder.BuildPartial();
break;
}
case 34: {
input.ReadMessageArray(tag, field_name, result.klList_, global::Qot_Common.KLine.DefaultInstance, extensionRegistry);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name)) {
if(tag == 0 && field_name != null) {
int field_ordinal = global::System.Array.BinarySearch(_responseFieldNames, field_name, global::System.StringComparer.Ordinal);
if(field_ordinal >= 0)
tag = _responseFieldTags[field_ordinal];
else {
if (unknownFields == null) {
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag) {
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag)) {
if (unknownFields != null) {
this.UnknownFields = unknownFields.Build();
}
return this;
}
if (unknownFields == null) {
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasRetType = input.ReadInt32(ref result.retType_);
break;
}
case 18: {
result.hasRetMsg = input.ReadString(ref result.retMsg_);
break;
}
case 24: {
result.hasErrCode = input.ReadInt32(ref result.errCode_);
break;
}
case 34: {
global::Futu.OpenApi.Pb.QotUpdateBasicQot.S2C.Builder subBuilder = global::Futu.OpenApi.Pb.QotUpdateBasicQot.S2C.CreateBuilder();
if (result.hasS2C) {
subBuilder.MergeFrom(S2C);
}
input.ReadMessage(subBuilder, extensionRegistry);
S2C = subBuilder.BuildPartial();
break;
}
}
}
if (unknownFields != null) {
this.UnknownFields = unknownFields.Build();
}
return this;
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_laidianCommandModelFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _laidianCommandModelFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
object unknown;
if (input.ReadEnum(ref result.messageType_, out unknown))
{
result.hasMessageType = true;
}
else if (unknown is int)
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
unknownFields.MergeVarintField(1, (ulong)(int)unknown);
}
break;
}
case 18: {
global::google.protobuf.Any.Builder subBuilder = global::google.protobuf.Any.CreateBuilder();
if (result.hasLaidianData)
{
subBuilder.MergeFrom(LaidianData);
}
input.ReadMessage(subBuilder, extensionRegistry);
LaidianData = subBuilder.BuildPartial();
break;
}
case 24: {
result.hasResult = input.ReadInt32(ref result.result_);
break;
}
case 34: {
result.hasMessage = input.ReadString(ref result.message_);
break;
}
case 42: {
result.hasTerminal = input.ReadString(ref result.terminal_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_sendMessageResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _sendMessageResponseFieldTags[field_ordinal];
}
else
{
ParseUnknownField(input, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
return(this);
}
ParseUnknownField(input, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasErrCode = input.ReadInt32(ref result.errCode_);
break;
}
case 18: {
result.hasErrMsg = input.ReadString(ref result.errMsg_);
break;
}
case 26: {
result.hasFrom = input.ReadString(ref result.from_);
break;
}
case 34: {
result.hasText = input.ReadString(ref result.text_);
break;
}
case 42: {
result.hasTopic = input.ReadString(ref result.topic_);
break;
}
}
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_lMDBConfigFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _lMDBConfigFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
object unknown;
if (input.ReadEnum(ref result.environmentOpenFlags_, out unknown))
{
result.hasEnvironmentOpenFlags = true;
}
else if (unknown is int)
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
unknownFields.MergeVarintField(1, (ulong)(int)unknown);
}
break;
}
case 16: {
result.hasMaxReaders = input.ReadInt32(ref result.maxReaders_);
break;
}
case 24: {
result.hasMaxTables = input.ReadInt32(ref result.maxTables_);
break;
}
case 32: {
result.hasInitialDatabaseSize = input.ReadInt64(ref result.initialDatabaseSize_);
break;
}
case 40: {
result.hasExpansionRatio = input.ReadInt64(ref result.expansionRatio_);
break;
}
case 48: {
result.hasCurrentDatabaseSize = input.ReadInt64(ref result.currentDatabaseSize_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_authenticationTokenFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _authenticationTokenFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasStatus = input.ReadInt32(ref result.status_);
break;
}
case 18: {
result.hasToken = input.ReadBytes(ref result.token_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_rOBPROPORTIONFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _rOBPROPORTIONFieldTags[field_ordinal];
}
else
{
ParseUnknownField(input, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
return(this);
}
ParseUnknownField(input, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasId = input.ReadInt32(ref result.id_);
break;
}
case 16: {
result.hasTransitDepot = input.ReadInt32(ref result.transitDepot_);
break;
}
case 24: {
result.hasBigWarehouse = input.ReadInt32(ref result.bigWarehouse_);
break;
}
case 32: {
result.hasBwLim = input.ReadInt32(ref result.bwLim_);
break;
}
case 40: {
result.hasGoldProp = input.ReadInt32(ref result.goldProp_);
break;
}
case 48: {
result.hasGoldLim = input.ReadInt32(ref result.goldLim_);
break;
}
}
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_createSessionCommandFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _createSessionCommandFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasClientId = input.ReadInt32(ref result.clientId_);
break;
}
case 18: {
global::Alachisoft.NosDB.Common.Protobuf.Credential.Builder subBuilder = global::Alachisoft.NosDB.Common.Protobuf.Credential.CreateBuilder();
if (result.hasCredential)
{
subBuilder.MergeFrom(Credential);
}
input.ReadMessage(subBuilder, extensionRegistry);
Credential = subBuilder.BuildPartial();
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_gameAccountSettingsFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _gameAccountSettingsFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasUseLastHero = input.ReadInt32(ref result.useLastHero_);
break;
}
case 16: {
result.hasShowOfflineToast = input.ReadInt32(ref result.showOfflineToast_);
break;
}
case 26: {
result.hasRmtLastUsedCurrency = input.ReadString(ref result.rmtLastUsedCurrency_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_pLAYERATTRFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _pLAYERATTRFieldTags[field_ordinal];
}
else
{
ParseUnknownField(input, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
return(this);
}
ParseUnknownField(input, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasId = input.ReadInt32(ref result.id_);
break;
}
case 18: {
result.hasPlayerAttrkey = input.ReadString(ref result.playerAttrkey_);
break;
}
case 24: {
result.hasBeginNum = input.ReadInt32(ref result.beginNum_);
break;
}
case 32: {
result.hasAttrK1 = input.ReadInt32(ref result.attrK1_);
break;
}
case 40: {
result.hasAttrK2 = input.ReadInt32(ref result.attrK2_);
break;
}
case 48: {
result.hasRecK1 = input.ReadInt32(ref result.recK1_);
break;
}
case 56: {
result.hasLimReal = input.ReadInt32(ref result.limReal_);
break;
}
case 64: {
result.hasLimK1 = input.ReadInt32(ref result.limK1_);
break;
}
case 72: {
result.hasLimK2 = input.ReadInt32(ref result.limK2_);
break;
}
case 80: {
result.hasSpcK1 = input.ReadInt32(ref result.spcK1_);
break;
}
case 88: {
result.hasSpcK2 = input.ReadInt32(ref result.spcK2_);
break;
}
}
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_testMessageFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _testMessageFieldTags[field_ordinal];
}
else
{
ParseUnknownField(input, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
return(this);
}
ParseUnknownField(input, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasId = input.ReadInt32(ref result.id_);
break;
}
case 18: {
global::Protobuf.EmbeddedMessage.Builder subBuilder = global::Protobuf.EmbeddedMessage.CreateBuilder();
if (result.hasEmbedded)
{
subBuilder.MergeFrom(Embedded);
}
input.ReadMessage(subBuilder, extensionRegistry);
Embedded = subBuilder.BuildPartial();
break;
}
case 26: {
result.hasText = input.ReadString(ref result.text_);
break;
}
}
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_sendCreateRoomFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _sendCreateRoomFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 10: {
result.hasUsername = input.ReadString(ref result.username_);
break;
}
case 16: {
result.hasIsWgj = input.ReadInt32(ref result.isWgj_);
break;
}
case 24: {
result.hasIsXinqiji = input.ReadInt32(ref result.isXinqiji_);
break;
}
case 32: {
result.hasIsShangxiaji = input.ReadInt32(ref result.isShangxiaji_);
break;
}
case 40: {
result.hasIsBenji = input.ReadInt32(ref result.isBenji_);
break;
}
case 48: {
result.hasIsYikousan = input.ReadInt32(ref result.isYikousan_);
break;
}
case 58: {
result.hasRoomPeo = input.ReadString(ref result.roomPeo_);
break;
}
case 64: {
result.hasCount = input.ReadInt32(ref result.count_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_crafterDataFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _crafterDataFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 10:
case 13: {
input.ReadSFixed32Array(tag, field_name, result.recipes_);
break;
}
case 18:
case 21: {
input.ReadSFixed32Array(tag, field_name, result.availableEnchants_);
break;
}
case 24: {
result.hasLevel = input.ReadInt32(ref result.level_);
break;
}
case 33: {
result.hasCooldownEnd = input.ReadSFixed64(ref result.cooldownEnd_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_areaSpeedingFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _areaSpeedingFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasAreaId = input.ReadInt64(ref result.areaId_);
break;
}
case 16: {
object unknown;
if (input.ReadEnum(ref result.types_, out unknown))
{
result.hasTypes = true;
}
else if (unknown is int)
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
unknownFields.MergeVarintField(2, (ulong)(int)unknown);
}
break;
}
case 24: {
result.hasRouteId = input.ReadInt64(ref result.routeId_);
break;
}
case 32: {
result.hasMaxSpeed = input.ReadInt32(ref result.maxSpeed_);
break;
}
case 40: {
result.hasContinuousTime = input.ReadInt32(ref result.continuousTime_);
break;
}
case 48: {
result.hasBasedTime = input.ReadBool(ref result.basedTime_);
break;
}
case 56: {
result.hasIsEveryDay = input.ReadBool(ref result.isEveryDay_);
break;
}
case 64: {
result.hasStartDate = input.ReadInt64(ref result.startDate_);
break;
}
case 72: {
result.hasEndDate = input.ReadInt64(ref result.endDate_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_personTestFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _personTestFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 10: {
result.hasName = input.ReadString(ref result.name_);
break;
}
case 16: {
result.hasId = input.ReadInt32(ref result.id_);
break;
}
case 26: {
result.hasEmail = input.ReadString(ref result.email_);
break;
}
case 34: {
result.hasSize = input.ReadString(ref result.size_);
break;
}
case 42: {
result.hasBuf = input.ReadBytes(ref result.buf_);
break;
}
case 48: {
result.hasIsimg = input.ReadBool(ref result.isimg_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_xtiveTagFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _xtiveTagFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 10: {
result.hasUid = input.ReadString(ref result.uid_);
break;
}
case 16: {
result.hasRssi = input.ReadInt32(ref result.rssi_);
break;
}
case 24: {
result.hasBLowPower = input.ReadBool(ref result.bLowPower_);
break;
}
case 32: {
result.hasBExcite = input.ReadBool(ref result.bExcite_);
break;
}
case 42: {
result.hasReaderIP = input.ReadString(ref result.readerIP_);
break;
}
case 50: {
result.hasAn = input.ReadString(ref result.an_);
break;
}
case 58: {
result.hasDateTime = input.ReadString(ref result.dateTime_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_a1024ResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _a1024ResponseFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 10: {
result.hasErrorInfo = input.ReadString(ref result.errorInfo_);
break;
}
case 16: {
result.hasErrorCode = input.ReadInt32(ref result.errorCode_);
break;
}
case 24: {
result.hasCard = input.ReadInt32(ref result.card_);
break;
}
case 34: {
result.hasUid = input.ReadString(ref result.uid_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_fooWithExtraFieldsFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _fooWithExtraFieldsFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
input.ReadInt32(ref result.int32Value_);
break;
}
case 16: {
object unknown;
if (input.ReadEnum(ref result.enumValue_, out unknown))
{
}
else if (unknown is int)
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
unknownFields.MergeVarintField(2, (ulong)(int)unknown);
}
break;
}
case 24: {
input.ReadInt32(ref result.extraInt32Value_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
