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();
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(_returnUserInfoFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _returnUserInfoFieldTags[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.ReadInt32(ref result.id_);
break;
}
case 16: {
result.hasRoomID = input.ReadInt32(ref result.roomID_);
break;
}
case 24: {
result.hasPalyStatus = input.ReadInt32(ref result.palyStatus_);
break;
}
case 34: {
result.hasHeadPortrait = input.ReadString(ref result.headPortrait_);
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(_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(_personFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _personFieldTags[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: {
input.ReadMessageArray(tag, field_name, result.phone_, global::cs.Person.Types.PhoneNumber.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(_gameAccountSettingsFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _gameAccountSettingsFieldTags[field_ordinal];
}
else
{
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
if (unknownFields == null)
{
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasUseLastHero = input.ReadInt32(ref result.useLastHero_);
break;
}
case 16: {
result.hasShowOfflineToast = input.ReadInt32(ref result.showOfflineToast_);
break;
}
case 26: {
result.hasRmtLastUsedCurrency = input.ReadString(ref result.rmtLastUsedCurrency_);
break;
}
}
}
if (unknownFields != null)
{
this.UnknownFields = unknownFields.Build();
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_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(_robotStatusFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _robotStatusFieldTags[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.capability_, out unknown))
{
result.hasCapability = 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.hasFunctionality = input.ReadString(ref result.functionality_);
break;
}
case 26: {
result.hasMetaData = input.ReadString(ref result.metaData_);
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(_beaconSignalFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _beaconSignalFieldTags[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.Time.Builder subBuilder = global::atwork_pb_msgs.Time.CreateBuilder();
if (result.hasTime)
{
subBuilder.MergeFrom(Time);
}
input.ReadMessage(subBuilder, extensionRegistry);
Time = subBuilder.BuildPartial();
break;
}
case 16: {
result.hasSeq = input.ReadUInt64(ref result.seq_);
break;
}
case 26: {
result.hasTeamName = input.ReadString(ref result.teamName_);
break;
}
case 34: {
result.hasPeerName = input.ReadString(ref result.peerName_);
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(_charSummaryFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _charSummaryFieldTags[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.hasServerId = input.ReadUInt32(ref result.serverId_);
break;
}
case 16: {
result.hasCharacterId = input.ReadUInt32(ref result.characterId_);
break;
}
case 24: {
result.hasLastPlayedTime = input.ReadInt64(ref result.lastPlayedTime_);
break;
}
case 34: {
result.hasXmlData = input.ReadString(ref result.xmlData_);
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(_bLVerifyAccountResultFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _bLVerifyAccountResultFieldTags[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.hasAccount = input.ReadString(ref result.account_);
break;
}
case 16: {
result.hasResult = input.ReadBool(ref result.result_);
break;
}
case 26: {
result.hasAccountId = input.ReadString(ref result.accountId_);
break;
}
case 32: {
result.hasOpCode = input.ReadInt32(ref result.opCode_);
break;
}
case 40: {
result.hasChannelId = input.ReadInt32(ref result.channelId_);
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(_a1004ResponseFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _a1004ResponseFieldTags[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 32: {
result.hasRoomID = input.ReadInt32(ref result.roomID_);
break;
}
case 40: {
result.hasRoomType = input.ReadInt32(ref result.roomType_);
break;
}
case 50: {
input.ReadMessageArray(tag, field_name, result.users_, global::DolphinServer.ProtoEntity.A1004User.DefaultInstance, extensionRegistry);
break;
}
case 56: {
result.hasCancelType = input.ReadInt32(ref result.cancelType_);
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(_eventFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _eventFieldTags[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.hasSumary = input.ReadString(ref result.sumary_);
break;
}
case 26: {
result.hasDetail = input.ReadString(ref result.detail_);
break;
}
case 32: {
result.hasTimestamp = input.ReadUInt64(ref result.timestamp_);
break;
}
case 42: {
global::BonreePB.BusinessTransaction.Builder subBuilder = global::BonreePB.BusinessTransaction.CreateBuilder();
if (result.hasBt)
{
subBuilder.MergeFrom(Bt);
}
input.ReadMessage(subBuilder, extensionRegistry);
Bt = 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(_laidianTaskModelFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _laidianTaskModelFieldTags[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.hasType = input.ReadString(ref result.type_);
break;
}
case 18: {
result.hasTaskId = input.ReadString(ref result.taskId_);
break;
}
case 26: {
result.hasLineType = input.ReadString(ref result.lineType_);
break;
}
case 34: {
result.hasCdbID = input.ReadString(ref result.cdbID_);
break;
}
case 42: {
result.hasUserNickName = input.ReadString(ref result.userNickName_);
break;
}
case 50: {
result.hasUserHeadPic = input.ReadString(ref result.userHeadPic_);
break;
}
case 58: {
result.hasResultStatus = input.ReadString(ref result.resultStatus_);
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(_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(_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)
{
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(_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();
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name))
{
if (tag == 0 && field_name != null)
{
int field_ordinal = global::System.Array.BinarySearch(_pLAYERATTRFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _pLAYERATTRFieldTags[field_ordinal];
}
else
{
ParseUnknownField(input, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag)
{
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
default: {
if (pb::WireFormat.IsEndGroupTag(tag))
{
return(this);
}
ParseUnknownField(input, extensionRegistry, tag, field_name);
break;
}
case 8: {
result.hasId = input.ReadInt32(ref result.id_);
break;
}
case 18: {
result.hasPlayerAttrkey = input.ReadString(ref result.playerAttrkey_);
break;
}
case 24: {
result.hasBeginNum = input.ReadInt32(ref result.beginNum_);
break;
}
case 32: {
result.hasAttrK1 = input.ReadInt32(ref result.attrK1_);
break;
}
case 40: {
result.hasAttrK2 = input.ReadInt32(ref result.attrK2_);
break;
}
case 48: {
result.hasRecK1 = input.ReadInt32(ref result.recK1_);
break;
}
case 56: {
result.hasLimReal = input.ReadInt32(ref result.limReal_);
break;
}
case 64: {
result.hasLimK1 = input.ReadInt32(ref result.limK1_);
break;
}
case 72: {
result.hasLimK2 = input.ReadInt32(ref result.limK2_);
break;
}
case 80: {
result.hasSpcK1 = input.ReadInt32(ref result.spcK1_);
break;
}
case 88: {
result.hasSpcK2 = input.ReadInt32(ref result.spcK2_);
break;
}
}
}
return(this);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
{
PrepareBuilder();
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();
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(_createCollectionCommandFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _createCollectionCommandFieldTags[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.hasCollectionName = input.ReadString(ref result.collectionName_);
break;
}
case 18: {
global::Alachisoft.NosDB.Common.Protobuf.IndicesConfig.Builder subBuilder = global::Alachisoft.NosDB.Common.Protobuf.IndicesConfig.CreateBuilder();
if (result.hasIndicesConfig)
{
subBuilder.MergeFrom(IndicesConfig);
}
input.ReadMessage(subBuilder, extensionRegistry);
IndicesConfig = subBuilder.BuildPartial();
break;
}
case 26: {
global::Alachisoft.NosDB.Common.Protobuf.CachingConfig.Builder subBuilder = global::Alachisoft.NosDB.Common.Protobuf.CachingConfig.CreateBuilder();
if (result.hasCaching)
{
subBuilder.MergeFrom(Caching);
}
input.ReadMessage(subBuilder, extensionRegistry);
Caching = 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(_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(_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(_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(_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(_anyFieldNames, field_name, global::System.StringComparer.Ordinal);
if (field_ordinal >= 0)
{
tag = _anyFieldTags[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.hasTypeUrl = input.ReadString(ref result.typeUrl_);
break;
}
case 18: {
result.hasValue = input.ReadBytes(ref result.value_);
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);
}
