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();
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(_emptyFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _emptyFieldTags[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;
}
}
}
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 10: {
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 18: {
input.ReadMessageArray(tag, field_name, result.tickerList_, global::Qot_Common.Ticker.DefaultInstance, extensionRegistry);
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(_conversationFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _conversationFieldTags[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.hasTopic = input.ReadString(ref result.topic_);
break;
}
case 18: {
result.hasNotice = input.ReadString(ref result.notice_);
break;
}
case 26: {
result.hasName = input.ReadString(ref result.name_);
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(_protoSlaveRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _protoSlaveRequestFieldTags[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.hasFunction = input.ReadBytes(ref result.function_);
break;
}
case 16: {
result.hasOutput = input.ReadBool(ref result.output_);
break;
}
case 26: {
input.ReadBytesArray(tag, field_name, result.parameter_);
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(_testLiteImportsNonliteFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _testLiteImportsNonliteFieldTags[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: {
global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.CreateBuilder();
if (result.hasMessage)
{
subBuilder.MergeFrom(Message);
}
input.ReadMessage(subBuilder, extensionRegistry);
Message = subBuilder.BuildPartial();
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(_hUAFEIARRAYFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _hUAFEIARRAYFieldTags[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: {
input.ReadMessageArray(tag, field_name, result.items_, global::com.nkm.framework.resource.data.HUAFEI.DefaultInstance, extensionRegistry);
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(_itemFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _itemFieldTags[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.hasItemId = input.ReadString(ref result.itemId_);
break;
}
case 26: {
result.hasName = input.ReadString(ref result.name_);
break;
}
case 34: {
result.hasDescription = input.ReadString(ref result.description_);
break;
}
case 42: {
result.hasCatalogName = input.ReadString(ref result.catalogName_);
break;
}
case 50: {
result.hasCatalogImageUrl = input.ReadString(ref result.catalogImageUrl_);
break;
}
case 58: {
result.hasItemImageUrl = input.ReadString(ref result.itemImageUrl_);
break;
}
case 73: {
result.hasPrice = input.ReadDouble(ref result.price_);
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(_testEmbedOptimizedForSizeFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _testEmbedOptimizedForSizeFieldTags[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: {
global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder();
if (result.hasOptionalMessage)
{
subBuilder.MergeFrom(OptionalMessage);
}
input.ReadMessage(subBuilder, extensionRegistry);
OptionalMessage = subBuilder.BuildPartial();
break;
}
case 18: {
input.ReadMessageArray(tag, field_name, result.repeatedMessage_, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.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(_normalFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _normalFieldTags[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.hasUserID = input.ReadUInt32(ref result.userID_);
break;
}
case 18: {
result.hasList = input.ReadString(ref result.list_);
break;
}
case 24: {
result.hasRmb = input.ReadUInt32(ref result.rmb_);
break;
}
case 32: {
result.hasFirstGif = input.ReadBool(ref result.firstGif_);
break;
}
case 42: {
result.hasBillNo = input.ReadString(ref result.billNo_);
break;
}
case 48: {
result.hasRmbActual = input.ReadUInt32(ref result.rmbActual_);
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(_infoFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _infoFieldTags[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.hasHirelingClass = input.ReadSInt32(ref result.hirelingClass_);
break;
}
case 21: {
result.hasGbidName = input.ReadSFixed32(ref result.gbidName_);
break;
}
case 24: {
result.hasLevel = input.ReadSInt32(ref result.level_);
break;
}
case 32: {
result.hasAttributeExperienceNext = input.ReadUInt32(ref result.attributeExperienceNext_);
break;
}
case 90:
case 88: {
input.ReadSInt32Array(tag, field_name, result.powerKeyParams_);
break;
}
case 96: {
result.hasDead = input.ReadBool(ref result.dead_);
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::Qot_UpdateKL.S2C.Builder subBuilder = global::Qot_UpdateKL.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(_a1012ResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _a1012ResponseFieldTags[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 26: {
result.hasUid = input.ReadString(ref result.uid_);
break;
}
case 32: {
result.hasCard = input.ReadInt32(ref result.card_);
break;
}
case 40: {
result.hasCard1 = input.ReadInt32(ref result.card1_);
break;
}
case 48: {
result.hasCard2 = input.ReadInt32(ref result.card2_);
break;
}
case 56: {
result.hasCardCode = input.ReadInt32(ref result.cardCode_);
break;
}
case 64: {
result.hasGangType = input.ReadInt32(ref result.gangType_);
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 10: {
global::Futu.OpenApi.Pb.TrdCommon.TrdHeader.Builder subBuilder = global::Futu.OpenApi.Pb.TrdCommon.TrdHeader.CreateBuilder();
if (result.hasHeader)
{
subBuilder.MergeFrom(Header);
}
input.ReadMessage(subBuilder, extensionRegistry);
Header = subBuilder.BuildPartial();
break;
}
case 16: {
result.hasType = input.ReadInt32(ref result.type_);
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(_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)
{
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(_combinedFingerprintsFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _combinedFingerprintsFieldTags[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.hasVersion = input.ReadUInt32(ref result.version_);
break;
}
case 18: {
global::WhisperSystems.Libsignal.Fingerprint.FingerprintProtos.LogicalFingerprint.Builder subBuilder = global::WhisperSystems.Libsignal.Fingerprint.FingerprintProtos.LogicalFingerprint.CreateBuilder();
if (result.hasLocalFingerprint)
{
subBuilder.MergeFrom(LocalFingerprint);
}
input.ReadMessage(subBuilder, extensionRegistry);
LocalFingerprint = subBuilder.BuildPartial();
break;
}
case 26: {
global::WhisperSystems.Libsignal.Fingerprint.FingerprintProtos.LogicalFingerprint.Builder subBuilder = global::WhisperSystems.Libsignal.Fingerprint.FingerprintProtos.LogicalFingerprint.CreateBuilder();
if (result.hasRemoteFingerprint)
{
subBuilder.MergeFrom(RemoteFingerprint);
}
input.ReadMessage(subBuilder, extensionRegistry);
RemoteFingerprint = 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(_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(_sessionNotificationFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _sessionNotificationFieldTags[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.hasSessionType = input.ReadUInt32(ref result.sessionType_);
break;
}
case 17: {
result.hasExpirationTimestamp = input.ReadFixed64(ref result.expirationTimestamp_);
break;
}
case 24: {
result.hasMinutesRemaining = input.ReadUInt32(ref result.minutesRemaining_);
break;
}
case 32: {
result.hasCaisPlayedMinutes = input.ReadUInt32(ref result.caisPlayedMinutes_);
break;
}
case 40: {
result.hasCaisRestedMinutes = input.ReadUInt32(ref result.caisRestedMinutes_);
break;
}
case 48: {
result.hasBenefactor = input.ReadBool(ref result.benefactor_);
break;
}
case 56: {
result.hasBillingMinutesRemaining = input.ReadUInt32(ref result.billingMinutesRemaining_);
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(_protoErrorResFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _protoErrorResFieldTags[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.payloadType_, out unknown))
{
result.hasPayloadType = true;
}
else if (unknown is int)
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
unknownFields.MergeVarintField(1, (ulong)(int)unknown);
}
break;
}
case 18: {
result.hasErrorCode = input.ReadString(ref result.errorCode_);
break;
}
case 26: {
result.hasDescription = input.ReadString(ref result.description_);
break;
}
case 32: {
result.hasMaintenanceEndTimestamp = input.ReadUInt64(ref result.maintenanceEndTimestamp_);
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(_packetFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _packetFieldTags[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.hasId = input.ReadInt64(ref result.id_);
break;
}
case 26: {
global::Com.Virtuos.Rocket.NetworkMessage.Message.Builder subBuilder = global::Com.Virtuos.Rocket.NetworkMessage.Message.CreateBuilder();
if (result.hasPayload)
{
subBuilder.MergeFrom(Payload);
}
input.ReadMessage(subBuilder, extensionRegistry);
Payload = 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(_inOutAreaFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _inOutAreaFieldTags[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: {
result.hasInAreaAlarmToDriver = input.ReadBool(ref result.inAreaAlarmToDriver_);
break;
}
case 24: {
result.hasInAreaAlarmToPlatform = input.ReadBool(ref result.inAreaAlarmToPlatform_);
break;
}
case 32: {
result.hasOutAreaAlarmToDriver = input.ReadBool(ref result.outAreaAlarmToDriver_);
break;
}
case 40: {
result.hasOutAreaAlarmToPlatform = input.ReadBool(ref result.outAreaAlarmToPlatform_);
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(_regularDataFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _regularDataFieldTags[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.hasTerminalId = input.ReadInt64(ref result.terminalId_);
break;
}
case 16: {
object unknown;
if (input.ReadEnum(ref result.regularCode_, out unknown))
{
result.hasRegularCode = 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.hasLastModifyDate = input.ReadInt64(ref result.lastModifyDate_);
break;
}
case 34: {
global::AeroCloud.Protocol.AreaSpeeding.Builder subBuilder = global::AeroCloud.Protocol.AreaSpeeding.CreateBuilder();
if (result.hasSpeeding)
{
subBuilder.MergeFrom(Speeding);
}
input.ReadMessage(subBuilder, extensionRegistry);
Speeding = subBuilder.BuildPartial();
break;
}
case 42: {
global::AeroCloud.Protocol.InOutArea.Builder subBuilder = global::AeroCloud.Protocol.InOutArea.CreateBuilder();
if (result.hasInOutArea)
{
subBuilder.MergeFrom(InOutArea);
}
input.ReadMessage(subBuilder, extensionRegistry);
InOutArea = subBuilder.BuildPartial();
break;
}
case 50: {
global::AeroCloud.Protocol.RouteDriverTime.Builder subBuilder = global::AeroCloud.Protocol.RouteDriverTime.CreateBuilder();
if (result.hasDriverTime)
{
subBuilder.MergeFrom(DriverTime);
}
input.ReadMessage(subBuilder, extensionRegistry);
DriverTime = subBuilder.BuildPartial();
break;
}
case 58: {
global::AeroCloud.Protocol.DriverNotCard.Builder subBuilder = global::AeroCloud.Protocol.DriverNotCard.CreateBuilder();
if (result.hasDriverNotCard)
{
subBuilder.MergeFrom(DriverNotCard);
}
input.ReadMessage(subBuilder, extensionRegistry);
DriverNotCard = subBuilder.BuildPartial();
break;
}
case 66: {
global::AeroCloud.Protocol.DoorOpenOutArea.Builder subBuilder = global::AeroCloud.Protocol.DoorOpenOutArea.CreateBuilder();
if (result.hasDoorOpenOutArea)
{
subBuilder.MergeFrom(DoorOpenOutArea);
}
input.ReadMessage(subBuilder, extensionRegistry);
DoorOpenOutArea = subBuilder.BuildPartial();
break;
}
case 74: {
global::AeroCloud.Protocol.DrivingBan.Builder subBuilder = global::AeroCloud.Protocol.DrivingBan.CreateBuilder();
if (result.hasDrivingBan)
{
subBuilder.MergeFrom(DrivingBan);
}
input.ReadMessage(subBuilder, extensionRegistry);
DrivingBan = 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(_getChunkResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _getChunkResponseFieldTags[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: {
global::Alachisoft.NosDB.Common.Protobuf.DataChunk.Builder subBuilder = global::Alachisoft.NosDB.Common.Protobuf.DataChunk.CreateBuilder();
if (result.hasDataChunk)
{
subBuilder.MergeFrom(DataChunk);
}
input.ReadMessage(subBuilder, extensionRegistry);
DataChunk = 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(_savedDataFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _savedDataFieldTags[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: {
input.ReadMessageArray(tag, field_name, result.hirelings_, global::D3.Hireling.Info.DefaultInstance, extensionRegistry);
break;
}
case 16: {
result.hasActiveHireling = input.ReadUInt32(ref result.activeHireling_);
break;
}
case 24: {
result.hasAvailableHirelingsBitfield = input.ReadUInt32(ref result.availableHirelingsBitfield_);
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(_identityFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _identityFieldTags[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: {
global::bnet.protocol.EntityId.Builder subBuilder = global::bnet.protocol.EntityId.CreateBuilder();
if (result.hasAccountId)
{
subBuilder.MergeFrom(AccountId);
}
input.ReadMessage(subBuilder, extensionRegistry);
AccountId = subBuilder.BuildPartial();
break;
}
case 18: {
global::bnet.protocol.EntityId.Builder subBuilder = global::bnet.protocol.EntityId.CreateBuilder();
if (result.hasGameAccountId)
{
subBuilder.MergeFrom(GameAccountId);
}
input.ReadMessage(subBuilder, extensionRegistry);
GameAccountId = subBuilder.BuildPartial();
break;
}
case 26: {
global::bnet.protocol.EntityId.Builder subBuilder = global::bnet.protocol.EntityId.CreateBuilder();
if (result.hasToonId)
{
subBuilder.MergeFrom(ToonId);
}
input.ReadMessage(subBuilder, extensionRegistry);
ToonId = 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);
}