public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _gamePropertiesFieldNames;
if (creationAttributes_.Count > 0)
{
output.WriteMessageArray(1, field_names[1], creationAttributes_);
}
if (hasFilter)
{
output.WriteMessage(2, field_names[2], Filter);
}
if (hasCreate)
{
output.WriteBool(3, field_names[0], Create);
}
if (hasOpen)
{
output.WriteBool(4, field_names[3], Open);
}
if (hasProgramId)
{
output.WriteFixed32(5, field_names[4], ProgramId);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _doorOpenOutAreaFieldNames;
if (hasAreaId)
{
output.WriteInt64(1, field_names[0], AreaId);
}
if (hasBasedTime)
{
output.WriteBool(2, field_names[1], BasedTime);
}
if (hasIsEveryDay)
{
output.WriteBool(3, field_names[3], IsEveryDay);
}
if (hasStartDate)
{
output.WriteInt64(4, field_names[4], StartDate);
}
if (hasEndDate)
{
output.WriteInt64(5, field_names[2], EndDate);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _xtiveTagFieldNames;
if (hasUid)
{
output.WriteString(1, field_names[6], Uid);
}
if (hasRssi)
{
output.WriteInt32(2, field_names[5], Rssi);
}
if (hasBLowPower)
{
output.WriteBool(3, field_names[2], BLowPower);
}
if (hasBExcite)
{
output.WriteBool(4, field_names[1], BExcite);
}
if (hasReaderIP)
{
output.WriteString(5, field_names[4], ReaderIP);
}
if (hasAn)
{
output.WriteString(6, field_names[0], An);
}
if (hasDateTime)
{
output.WriteString(7, field_names[3], DateTime);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _infoFieldNames;
if (hasHirelingClass)
{
output.WriteSInt32(1, field_names[3], HirelingClass);
}
if (hasGbidName)
{
output.WriteSFixed32(2, field_names[2], GbidName);
}
if (hasLevel)
{
output.WriteSInt32(3, field_names[4], Level);
}
if (hasAttributeExperienceNext)
{
output.WriteUInt32(4, field_names[0], AttributeExperienceNext);
}
if (powerKeyParams_.Count > 0)
{
output.WriteSInt32Array(11, field_names[5], powerKeyParams_);
}
if (hasDead)
{
output.WriteBool(12, field_names[1], Dead);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _personTestFieldNames;
if (hasName)
{
output.WriteString(1, field_names[4], Name);
}
if (hasId)
{
output.WriteInt32(2, field_names[2], Id);
}
if (hasEmail)
{
output.WriteString(3, field_names[1], Email);
}
if (hasSize)
{
output.WriteString(4, field_names[5], Size);
}
if (hasBuf)
{
output.WriteBytes(5, field_names[0], Buf);
}
if (hasIsimg)
{
output.WriteBool(6, field_names[3], Isimg);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _robotFieldNames;
if (hasName)
{
output.WriteString(1, field_names[3], Name);
}
if (hasTeam)
{
output.WriteString(2, field_names[4], Team);
}
if (hasHost)
{
output.WriteString(3, field_names[0], Host);
}
if (hasLastSeen)
{
output.WriteMessage(4, field_names[2], LastSeen);
}
if (hasIsLogging)
{
output.WriteBool(5, field_names[1], IsLogging);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _sessionNotificationFieldNames;
if (hasSessionType)
{
output.WriteUInt32(1, field_names[6], SessionType);
}
if (hasExpirationTimestamp)
{
output.WriteFixed64(2, field_names[4], ExpirationTimestamp);
}
if (hasMinutesRemaining)
{
output.WriteUInt32(3, field_names[5], MinutesRemaining);
}
if (hasCaisPlayedMinutes)
{
output.WriteUInt32(4, field_names[2], CaisPlayedMinutes);
}
if (hasCaisRestedMinutes)
{
output.WriteUInt32(5, field_names[3], CaisRestedMinutes);
}
if (hasBenefactor)
{
output.WriteBool(6, field_names[0], Benefactor);
}
if (hasBillingMinutesRemaining)
{
output.WriteUInt32(7, field_names[1], BillingMinutesRemaining);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _channelStateFieldNames;
if (hasIdentity)
{
output.WriteString(1, field_names[1], Identity);
}
if (hasProgram)
{
output.WriteFixed32(2, field_names[3], Program);
}
if (hasLocale)
{
output.WriteFixed32(3, field_names[2], Locale);
}
if (hasPublic)
{
output.WriteBool(4, field_names[4], Public);
}
if (hasBucketIndex)
{
output.WriteUInt32(5, field_names[0], BucketIndex);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _storageProviderConfigFieldNames;
if (hasMaxDatabaseSize)
{
output.WriteInt64(1, field_names[3], MaxDatabaseSize);
}
if (hasProviderTypeString)
{
output.WriteString(2, field_names[4], ProviderTypeString);
}
if (hasIsMultiFileStore)
{
output.WriteBool(3, field_names[1], IsMultiFileStore);
}
if (hasLMDBProvider)
{
output.WriteMessage(4, field_names[2], LMDBProvider);
}
if (hasESENTProvider)
{
output.WriteMessage(5, field_names[0], ESENTProvider);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _normalFieldNames;
if (hasUserID)
{
output.WriteUInt32(1, field_names[5], UserID);
}
if (hasList)
{
output.WriteString(2, field_names[2], List);
}
if (hasRmb)
{
output.WriteUInt32(3, field_names[3], Rmb);
}
if (hasFirstGif)
{
output.WriteBool(4, field_names[1], FirstGif);
}
if (hasBillNo)
{
output.WriteString(5, field_names[0], BillNo);
}
if (hasRmbActual)
{
output.WriteUInt32(6, field_names[4], RmbActual);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _bLVerifyAccountResultFieldNames;
if (hasAccount)
{
output.WriteString(1, field_names[0], Account);
}
if (hasResult)
{
output.WriteBool(2, field_names[4], Result);
}
if (hasAccountId)
{
output.WriteString(3, field_names[1], AccountId);
}
if (hasOpCode)
{
output.WriteInt32(4, field_names[3], OpCode);
}
if (hasChannelId)
{
output.WriteInt32(5, field_names[2], ChannelId);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _loggingStatusFieldNames;
if (hasIsLogging)
{
output.WriteBool(1, field_names[0], IsLogging);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _areaSpeedingFieldNames;
if (hasAreaId)
{
output.WriteInt64(1, field_names[0], AreaId);
}
if (hasTypes)
{
output.WriteEnum(2, field_names[8], (int)Types, Types);
}
if (hasRouteId)
{
output.WriteInt64(3, field_names[6], RouteId);
}
if (hasMaxSpeed)
{
output.WriteInt32(4, field_names[5], MaxSpeed);
}
if (hasContinuousTime)
{
output.WriteInt32(5, field_names[2], ContinuousTime);
}
if (hasBasedTime)
{
output.WriteBool(6, field_names[1], BasedTime);
}
if (hasIsEveryDay)
{
output.WriteBool(7, field_names[4], IsEveryDay);
}
if (hasStartDate)
{
output.WriteInt64(8, field_names[7], StartDate);
}
if (hasEndDate)
{
output.WriteInt64(9, field_names[3], EndDate);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _initDatabaseResponseFieldNames;
if (hasIsDatabaseInitialized)
{
output.WriteBool(1, field_names[0], IsDatabaseInitialized);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _friendInvitationFieldNames;
if (hasFirstReceived)
{
output.WriteBool(1, field_names[0], FirstReceived);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _routeDriverTimeFieldNames;
if (hasRouteId)
{
output.WriteInt64(1, field_names[6], RouteId);
}
if (hasLineId)
{
output.WriteInt64(2, field_names[3], LineId);
}
if (hasMaxTime)
{
output.WriteInt32(3, field_names[4], MaxTime);
}
if (hasMinTime)
{
output.WriteInt32(4, field_names[5], MinTime);
}
if (hasBasedTime)
{
output.WriteBool(5, field_names[0], BasedTime);
}
if (hasIsEveryDay)
{
output.WriteBool(6, field_names[2], IsEveryDay);
}
if (hasStartDate)
{
output.WriteInt64(7, field_names[7], StartDate);
}
if (hasEndDate)
{
output.WriteInt64(8, field_names[1], EndDate);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _normalRepFieldNames;
if (hasUserID)
{
output.WriteUInt32(1, field_names[1], UserID);
}
if (hasSuc)
{
output.WriteBool(2, field_names[0], Suc);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _pbNewsPromptFieldNames;
if (hasNewsPromptId)
{
output.WriteInt32(1, field_names[1], NewsPromptId);
}
if (hasIsShow)
{
output.WriteBool(2, field_names[0], IsShow);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _questStepCompleteFieldNames;
if (hasIsQuestComplete)
{
output.WriteBool(1, field_names[0], IsQuestComplete);
}
if (hasReward)
{
output.WriteMessage(2, field_names[1], Reward);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _accountInfoFieldNames;
if (hasAccountPaid)
{
output.WriteBool(1, field_names[0], AccountPaid);
}
if (hasCountryId)
{
output.WriteFixed32(2, field_names[1], CountryId);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _compDataPackageFieldNames;
if (hasComp)
{
output.WriteBool(1, field_names[0], Comp);
}
if (hasInfo)
{
output.WriteBytes(2, field_names[1], Info);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _msgMLQueryResultFieldNames;
if (hasIsOk)
{
output.WriteBool(1, field_names[0], IsOk);
}
if (hasResult)
{
output.WriteString(2, field_names[1], Result);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _protoSlaveRequestFieldNames;
if (hasFunction)
{
output.WriteBytes(1, field_names[0], Function);
}
if (hasOutput)
{
output.WriteBool(2, field_names[1], Output);
}
if (parameter_.Count > 0)
{
output.WriteBytesArray(3, field_names[2], parameter_);
}
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _dropIndexCommandFieldNames;
if (attributes_.Count > 0)
{
output.WriteStringArray(1, field_names[1], attributes_);
}
if (hasIsAsync)
{
output.WriteBool(2, field_names[2], IsAsync);
}
if (hasIndexDropedCallbackId)
{
output.WriteSInt32(3, field_names[0], IndexDropedCallbackId);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _createIndexCommandFieldNames;
if (hasIndexName)
{
output.WriteString(1, field_names[2], IndexName);
}
if (hasAttributes)
{
output.WriteMessage(2, field_names[0], Attributes);
}
if (hasCachePolicy)
{
output.WriteString(3, field_names[1], CachePolicy);
}
if (hasJournalEnabled)
{
output.WriteBool(4, field_names[3], JournalEnabled);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _bTDataItemFieldNames;
if (hasRequestGuid)
{
output.WriteString(1, field_names[1], RequestGuid);
}
if (hasRespTime)
{
output.WriteUInt32(2, field_names[2], RespTime);
}
if (hasBHasSnapshot)
{
output.WriteBool(3, field_names[0], BHasSnapshot);
}
if (hasTransactionName)
{
output.WriteString(4, field_names[3], TransactionName);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _dataChunkFieldNames;
if (hasChunkId)
{
output.WriteInt32(1, field_names[0], ChunkId);
}
if (hasReaderUId)
{
output.WriteString(2, field_names[3], ReaderUId);
}
if (documents_.Count > 0)
{
output.WriteStringArray(3, field_names[1], documents_);
}
if (hasIsLastChunk)
{
output.WriteBool(4, field_names[2], IsLastChunk);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _drivingBanFieldNames;
if (hasBanIdentify)
{
output.WriteInt64(1, field_names[0], BanIdentify);
}
if (hasIsEveryDay)
{
output.WriteBool(2, field_names[2], IsEveryDay);
}
if (hasStartDate)
{
output.WriteInt64(3, field_names[3], StartDate);
}
if (hasEndDate)
{
output.WriteInt64(4, field_names[1], EndDate);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _inOutAreaFieldNames;
if (hasAreaId)
{
output.WriteInt64(1, field_names[0], AreaId);
}
if (hasInAreaAlarmToDriver)
{
output.WriteBool(2, field_names[3], InAreaAlarmToDriver);
}
if (hasInAreaAlarmToPlatform)
{
output.WriteBool(3, field_names[4], InAreaAlarmToPlatform);
}
if (hasOutAreaAlarmToDriver)
{
output.WriteBool(4, field_names[6], OutAreaAlarmToDriver);
}
if (hasOutAreaAlarmToPlatform)
{
output.WriteBool(5, field_names[7], OutAreaAlarmToPlatform);
}
if (hasBasedTime)
{
output.WriteBool(6, field_names[1], BasedTime);
}
if (hasIsEveryDay)
{
output.WriteBool(7, field_names[5], IsEveryDay);
}
if (hasStartDate)
{
output.WriteInt64(8, field_names[8], StartDate);
}
if (hasEndDate)
{
output.WriteInt64(9, field_names[2], EndDate);
}
UnknownFields.WriteTo(output);
}