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(_lineSensorFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _lineSensorFieldTags[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::lth.line_sensor.Point.Builder subBuilder = global::lth.line_sensor.Point.CreateBuilder();
if (result.hasSensedPoint)
{
subBuilder.MergeFrom(SensedPoint);
}
input.ReadMessage(subBuilder, extensionRegistry);
SensedPoint = subBuilder.BuildPartial();
break;
}
case 18: {
global::lth.line_sensor.Point.Builder subBuilder = global::lth.line_sensor.Point.CreateBuilder();
if (result.hasStart)
{
subBuilder.MergeFrom(Start);
}
input.ReadMessage(subBuilder, extensionRegistry);
Start = subBuilder.BuildPartial();
break;
}
case 26: {
global::lth.line_sensor.Point.Builder subBuilder = global::lth.line_sensor.Point.CreateBuilder();
if (result.hasEnd)
{
subBuilder.MergeFrom(End);
}
input.ReadMessage(subBuilder, extensionRegistry);
End = subBuilder.BuildPartial();
break;
}
case 33: {
result.hasRadius = input.ReadDouble(ref result.radius_);
break;
}
case 42: {
result.hasSensedPart = input.ReadString(ref result.sensedPart_);
break;
}
case 48: {
result.hasSensorID = input.ReadUInt32(ref result.sensorID_);
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.QotUpdateRT.S2C.Builder subBuilder = global::Futu.OpenApi.Pb.QotUpdateRT.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(_selectionFieldNames, field_name,
global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _selectionFieldTags[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.type_, out unknown))
{
result.hasType = 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.hasMatcher = input.ReadString(ref result.matcher_);
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(_combinedFingerprintFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _combinedFingerprintFieldTags[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::libsignal.fingerprint.FingerprintProtos.FingerprintData.Builder subBuilder = global::libsignal.fingerprint.FingerprintProtos.FingerprintData.CreateBuilder();
if (result.hasLocalFingerprint)
{
subBuilder.MergeFrom(LocalFingerprint);
}
input.ReadMessage(subBuilder, extensionRegistry);
LocalFingerprint = subBuilder.BuildPartial();
break;
}
case 26: {
global::libsignal.fingerprint.FingerprintProtos.FingerprintData.Builder subBuilder = global::libsignal.fingerprint.FingerprintProtos.FingerprintData.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::CodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
pb::UnknownFieldSet.Builder unknownFields = null;
while (true)
{
uint tag = input.ReadTag();
switch (tag)
{
case 0: {
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
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);
break;
}
case 10: {
Namespace = input.ReadString();
break;
}
case 18: {
UmbrellaClassname = input.ReadString();
break;
}
case 24: {
PublicClasses = input.ReadBool();
break;
}
case 32: {
MultipleFiles = input.ReadBool();
break;
}
case 40: {
NestClasses = input.ReadBool();
break;
}
case 48: {
CodeContracts = input.ReadBool();
break;
}
case 56: {
ExpandNamespaceDirectories = input.ReadBool();
break;
}
case 64: {
ClsCompliance = input.ReadBool();
break;
}
case 1770: {
FileExtension = input.ReadString();
break;
}
case 1778: {
UmbrellaNamespace = input.ReadString();
break;
}
case 1786: {
OutputDirectory = input.ReadString();
break;
}
case 1792: {
IgnoreGoogleProtobuf = input.ReadBool();
break;
}
}
}
}
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(_authenticationCommandFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _authenticationCommandFieldTags[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.AuthenticationToken.Builder subBuilder = global::Alachisoft.NosDB.Common.Protobuf.AuthenticationToken.CreateBuilder();
if (result.hasAuthenticationToken)
{
subBuilder.MergeFrom(AuthenticationToken);
}
input.ReadMessage(subBuilder, extensionRegistry);
AuthenticationToken = subBuilder.BuildPartial();
break;
}
case 18: {
result.hasConnectionString = input.ReadString(ref result.connectionString_);
break;
}
case 26: {
result.hasProcessID = input.ReadString(ref result.processID_);
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(_agentIdentityFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _agentIdentityFieldTags[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.hasAccountGUID = input.ReadString(ref result.accountGUID_);
break;
}
case 18: {
result.hasAppGUID = input.ReadString(ref result.appGUID_);
break;
}
case 26: {
result.hasClusterGUID = input.ReadString(ref result.clusterGUID_);
break;
}
case 34: {
result.hasTierGUID = input.ReadString(ref result.tierGUID_);
break;
}
case 42: {
result.hasNodeGUID = input.ReadString(ref result.nodeGUID_);
break;
}
case 50: {
result.hasAgentGUID = input.ReadString(ref result.agentGUID_);
break;
}
case 56: {
result.hasAccountID = input.ReadUInt32(ref result.accountID_);
break;
}
case 64: {
result.hasAppID = input.ReadUInt32(ref result.appID_);
break;
}
case 72: {
result.hasClusterID = input.ReadUInt32(ref result.clusterID_);
break;
}
case 80: {
result.hasTierID = input.ReadUInt32(ref result.tierID_);
break;
}
case 88: {
result.hasNodeID = input.ReadUInt32(ref result.nodeID_);
break;
}
case 96: {
result.hasAgentID = input.ReadUInt32(ref result.agentID_);
break;
}
case 104: {
object unknown;
if (input.ReadEnum(ref result.agentType_, out unknown))
{
result.hasAgentType = true;
}
else if (unknown is int)
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
unknownFields.MergeVarintField(13, (ulong)(int)unknown);
}
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(_transportationTaskFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _transportationTaskFieldTags[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::atwork_pb_msgs.ObjectIdentifier.Builder subBuilder = global::atwork_pb_msgs.ObjectIdentifier.CreateBuilder();
if (result.hasObject)
{
subBuilder.MergeFrom(Object);
}
input.ReadMessage(subBuilder, extensionRegistry);
Object = subBuilder.BuildPartial();
break;
}
case 18: {
global::atwork_pb_msgs.ObjectIdentifier.Builder subBuilder = global::atwork_pb_msgs.ObjectIdentifier.CreateBuilder();
if (result.hasContainer)
{
subBuilder.MergeFrom(Container);
}
input.ReadMessage(subBuilder, extensionRegistry);
Container = subBuilder.BuildPartial();
break;
}
case 24: {
result.hasQuantityDelivered = input.ReadUInt64(ref result.quantityDelivered_);
break;
}
case 32: {
result.hasQuantityRequested = input.ReadUInt64(ref result.quantityRequested_);
break;
}
case 42: {
global::atwork_pb_msgs.LocationIdentifier.Builder subBuilder = global::atwork_pb_msgs.LocationIdentifier.CreateBuilder();
if (result.hasDestination)
{
subBuilder.MergeFrom(Destination);
}
input.ReadMessage(subBuilder, extensionRegistry);
Destination = subBuilder.BuildPartial();
break;
}
case 50: {
global::atwork_pb_msgs.LocationIdentifier.Builder subBuilder = global::atwork_pb_msgs.LocationIdentifier.CreateBuilder();
if (result.hasSource)
{
subBuilder.MergeFrom(Source);
}
input.ReadMessage(subBuilder, extensionRegistry);
Source = subBuilder.BuildPartial();
break;
}
case 58: {
result.hasProcessingTeam = input.ReadString(ref result.processingTeam_);
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(_taskFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _taskFieldTags[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.ReadUInt64(ref result.id_);
break;
}
case 16: {
object unknown;
if (input.ReadEnum(ref result.type_, out unknown))
{
result.hasType = true;
}
else if (unknown is int)
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
unknownFields.MergeVarintField(2, (ulong)(int)unknown);
}
break;
}
case 24: {
object unknown;
if (input.ReadEnum(ref result.status_, out unknown))
{
result.hasStatus = true;
}
else if (unknown is int)
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
unknownFields.MergeVarintField(3, (ulong)(int)unknown);
}
break;
}
case 34: {
global::atwork_pb_msgs.TransportationTask.Builder subBuilder = global::atwork_pb_msgs.TransportationTask.CreateBuilder();
if (result.hasTransportationTask)
{
subBuilder.MergeFrom(TransportationTask);
}
input.ReadMessage(subBuilder, extensionRegistry);
TransportationTask = subBuilder.BuildPartial();
break;
}
case 42: {
global::atwork_pb_msgs.NavigationTask.Builder subBuilder = global::atwork_pb_msgs.NavigationTask.CreateBuilder();
if (result.hasNavigationTask)
{
subBuilder.MergeFrom(NavigationTask);
}
input.ReadMessage(subBuilder, extensionRegistry);
NavigationTask = 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(_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)
{
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(_storageProviderConfigFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _storageProviderConfigFieldTags[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.hasMaxDatabaseSize = input.ReadInt64(ref result.maxDatabaseSize_);
break;
}
case 18: {
result.hasProviderTypeString = input.ReadString(ref result.providerTypeString_);
break;
}
case 24: {
result.hasIsMultiFileStore = input.ReadBool(ref result.isMultiFileStore_);
break;
}
case 34: {
global::Alachisoft.NosDB.Common.Protobuf.LMDBConfig.Builder subBuilder = global::Alachisoft.NosDB.Common.Protobuf.LMDBConfig.CreateBuilder();
if (result.hasLMDBProvider)
{
subBuilder.MergeFrom(LMDBProvider);
}
input.ReadMessage(subBuilder, extensionRegistry);
LMDBProvider = subBuilder.BuildPartial();
break;
}
case 42: {
global::Alachisoft.NosDB.Common.Protobuf.ESENTConfig.Builder subBuilder = global::Alachisoft.NosDB.Common.Protobuf.ESENTConfig.CreateBuilder();
if (result.hasESENTProvider)
{
subBuilder.MergeFrom(ESENTProvider);
}
input.ReadMessage(subBuilder, extensionRegistry);
ESENTProvider = 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(_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)
{
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(_toonInfoFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _toonInfoFieldTags[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.toon.ToonName.Builder subBuilder = global::bnet.protocol.toon.ToonName.CreateBuilder();
if (result.hasName)
{
subBuilder.MergeFrom(Name);
}
input.ReadMessage(subBuilder, extensionRegistry);
Name = subBuilder.BuildPartial();
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
pb::UnknownFieldSet.Builder unknownFields = null;
while (true)
{
uint tag = input.ReadTag();
switch (tag)
{
case 0: {
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
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);
break;
}
case 8: {
StartTime = input.ReadSInt64();
break;
}
case 16: {
SecondsToSearch = input.ReadUInt32();
break;
}
case 26: {
global::D3.OnlineService.GameCreateParams.Builder subBuilder = global::D3.OnlineService.GameCreateParams.CreateBuilder();
if (HasGameParams)
{
subBuilder.MergeFrom(GameParams);
}
input.ReadMessage(subBuilder, extensionRegistry);
GameParams = subBuilder.BuildPartial();
break;
}
case 32: {
RemoveReason = input.ReadInt32();
break;
}
}
}
}
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(_laidianStatusModelFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _laidianStatusModelFieldTags[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 18: {
result.hasType = input.ReadString(ref result.type_);
break;
}
case 26: {
result.hasTerminal = input.ReadString(ref result.terminal_);
break;
}
case 34: {
result.hasTime = input.ReadString(ref result.time_);
break;
}
case 42: {
result.hasVd = input.ReadString(ref result.vd_);
break;
}
case 50: {
result.hasSmk = input.ReadString(ref result.smk_);
break;
}
case 58: {
result.hasTemp = input.ReadString(ref result.temp_);
break;
}
case 66: {
result.hasStatus = input.ReadString(ref result.status_);
break;
}
case 74: {
result.hasHsnum = input.ReadString(ref result.hsnum_);
break;
}
case 82: {
result.hasLinesstatus = input.ReadString(ref result.linesstatus_);
break;
}
case 90:
case 88: {
input.ReadInt32Array(tag, field_name, result.lines_);
break;
}
case 98: {
input.ReadMessageArray(tag, field_name, result.cdbs_, global::com.imlaidian.protobuf.model.CDBStatusModel.DefaultInstance, extensionRegistry);
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(_crafterSavedDataFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _crafterSavedDataFieldTags[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.crafterData_, global::D3.ItemCrafting.CrafterData.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(_gamePropertiesFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _gamePropertiesFieldTags[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.creationAttributes_, global::bnet.protocol.attribute.Attribute.DefaultInstance, extensionRegistry);
break;
}
case 18: {
global::bnet.protocol.attribute.AttributeFilter.Builder subBuilder = global::bnet.protocol.attribute.AttributeFilter.CreateBuilder();
if (result.hasFilter)
{
subBuilder.MergeFrom(Filter);
}
input.ReadMessage(subBuilder, extensionRegistry);
Filter = subBuilder.BuildPartial();
break;
}
case 24: {
result.hasCreate = input.ReadBool(ref result.create_);
break;
}
case 32: {
result.hasOpen = input.ReadBool(ref result.open_);
break;
}
case 45: {
result.hasProgramId = input.ReadFixed32(ref result.programId_);
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(_a1014ResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _a1014ResponseFieldTags[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.hasHuType = input.ReadInt32(ref result.huType_);
break;
}
case 42: {
result.hasDesUid = input.ReadString(ref result.desUid_);
break;
}
case 48: {
result.hasCard1 = input.ReadInt32(ref result.card1_);
break;
}
case 56: {
result.hasCard2 = input.ReadInt32(ref result.card2_);
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(_contentHandleFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _contentHandleFieldTags[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 13: {
result.hasRegion = input.ReadFixed32(ref result.region_);
break;
}
case 21: {
result.hasUsage = input.ReadFixed32(ref result.usage_);
break;
}
case 26: {
result.hasHash = input.ReadBytes(ref result.hash_);
break;
}
case 34: {
result.hasProtoUrl = input.ReadString(ref result.protoUrl_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
pb::UnknownFieldSet.Builder unknownFields = null;
while (true)
{
uint tag = input.ReadTag();
switch (tag)
{
case 0: {
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
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);
break;
}
case 8: {
HirelingClass = input.ReadSInt32();
break;
}
case 21: {
GbidName = input.ReadSFixed32();
break;
}
case 24: {
Level = input.ReadSInt32();
break;
}
case 32: {
AttributeExperienceNext = input.ReadUInt32();
break;
}
case 88: {
AddPowerKeyParams(input.ReadSInt32());
break;
}
case 96: {
Dead = input.ReadBool();
break;
}
}
}
}
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 10: {
global::Futu.OpenApi.Pb.QotCommon.Security.Builder subBuilder = global::Futu.OpenApi.Pb.QotCommon.Security.CreateBuilder();
if (result.hasSecurity)
{
subBuilder.MergeFrom(Security);
}
input.ReadMessage(subBuilder, extensionRegistry);
Security = subBuilder.BuildPartial();
break;
}
case 18: {
input.ReadMessageArray(tag, field_name, result.rtList_, global::Futu.OpenApi.Pb.QotCommon.TimeShare.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(_pbDecodeRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _pbDecodeRequestFieldTags[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.hasIMEI = input.ReadString(ref result.iMEI_);
break;
}
case 18: {
input.ReadBytesArray(tag, field_name, result.decodes_);
break;
}
case 25: {
result.hasLatitude = input.ReadDouble(ref result.latitude_);
break;
}
case 33: {
result.hasLongitude = input.ReadDouble(ref result.longitude_);
break;
}
case 42: {
result.hasCode = input.ReadString(ref result.code_);
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(_pbNewsPromptFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _pbNewsPromptFieldTags[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.hasNewsPromptId = input.ReadInt32(ref result.newsPromptId_);
break;
}
case 16: {
result.hasIsShow = input.ReadBool(ref result.isShow_);
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(_questStepCompleteFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _questStepCompleteFieldTags[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.hasIsQuestComplete = input.ReadBool(ref result.isQuestComplete_);
break;
}
case 18: {
global::D3.Quests.QuestReward.Builder subBuilder = global::D3.Quests.QuestReward.CreateBuilder();
if (result.hasReward)
{
subBuilder.MergeFrom(Reward);
}
input.ReadMessage(subBuilder, extensionRegistry);
Reward = 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(_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(_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);
}