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();
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(_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(_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(_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(_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(_createIndexCommandFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _createIndexCommandFieldTags[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.hasIndexName = input.ReadString(ref result.indexName_);
break;
}
case 18: {
global::Alachisoft.NosDB.Common.Protobuf.IndexAttributeProto.Builder subBuilder = global::Alachisoft.NosDB.Common.Protobuf.IndexAttributeProto.CreateBuilder();
if (result.hasAttributes)
{
subBuilder.MergeFrom(Attributes);
}
input.ReadMessage(subBuilder, extensionRegistry);
Attributes = subBuilder.BuildPartial();
break;
}
case 26: {
result.hasCachePolicy = input.ReadString(ref result.cachePolicy_);
break;
}
case 32: {
result.hasJournalEnabled = input.ReadBool(ref result.journalEnabled_);
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(_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(_channelStateFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _channelStateFieldTags[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.hasIdentity = input.ReadString(ref result.identity_);
break;
}
case 21: {
result.hasProgram = input.ReadFixed32(ref result.program_);
break;
}
case 29: {
result.hasLocale = input.ReadFixed32(ref result.locale_);
break;
}
case 32: {
result.hasPublic = input.ReadBool(ref result.public_);
break;
}
case 40: {
result.hasBucketIndex = input.ReadUInt32(ref result.bucketIndex_);
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(_robotFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _robotFieldTags[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 18: {
result.hasTeam = input.ReadString(ref result.team_);
break;
}
case 26: {
result.hasHost = input.ReadString(ref result.host_);
break;
}
case 34: {
global::atwork_pb_msgs.Time.Builder subBuilder = global::atwork_pb_msgs.Time.CreateBuilder();
if (result.hasLastSeen)
{
subBuilder.MergeFrom(LastSeen);
}
input.ReadMessage(subBuilder, extensionRegistry);
LastSeen = subBuilder.BuildPartial();
break;
}
case 40: {
result.hasIsLogging = input.ReadBool(ref result.isLogging_);
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(_bTDataItemFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _bTDataItemFieldTags[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.hasRequestGuid = input.ReadString(ref result.requestGuid_);
break;
}
case 16: {
result.hasRespTime = input.ReadUInt32(ref result.respTime_);
break;
}
case 24: {
result.hasBHasSnapshot = input.ReadBool(ref result.bHasSnapshot_);
break;
}
case 34: {
result.hasTransactionName = input.ReadString(ref result.transactionName_);
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(_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(_accountInfoFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _accountInfoFieldTags[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.hasAccountPaid = input.ReadBool(ref result.accountPaid_);
break;
}
case 21: {
result.hasCountryId = input.ReadFixed32(ref result.countryId_);
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(_dropIndexCommandFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _dropIndexCommandFieldTags[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.ReadStringArray(tag, field_name, result.attributes_);
break;
}
case 16: {
result.hasIsAsync = input.ReadBool(ref result.isAsync_);
break;
}
case 24: {
result.hasIndexDropedCallbackId = input.ReadSInt32(ref result.indexDropedCallbackId_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
