public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _taskFieldNames;
if (hasId)
{
output.WriteUInt64(1, field_names[0], Id);
}
if (hasType)
{
output.WriteEnum(2, field_names[4], (int)Type, Type);
}
if (hasStatus)
{
output.WriteEnum(3, field_names[2], (int)Status, Status);
}
if (hasTransportationTask)
{
output.WriteMessage(4, field_names[3], TransportationTask);
}
if (hasNavigationTask)
{
output.WriteMessage(5, field_names[1], NavigationTask);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _benchmarkControlFieldNames;
if (hasPhaseToTerminate)
{
output.WriteEnum(1, field_names[0], (int)PhaseToTerminate, PhaseToTerminate);
}
if (hasState)
{
output.WriteEnum(2, field_names[1], (int)State, State);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _lMDBConfigFieldNames;
if (hasEnvironmentOpenFlags)
{
output.WriteEnum(1, field_names[1], (int)EnvironmentOpenFlags, EnvironmentOpenFlags);
}
if (hasMaxReaders)
{
output.WriteInt32(2, field_names[4], MaxReaders);
}
if (hasMaxTables)
{
output.WriteInt32(3, field_names[5], MaxTables);
}
if (hasInitialDatabaseSize)
{
output.WriteInt64(4, field_names[3], InitialDatabaseSize);
}
if (hasExpansionRatio)
{
output.WriteInt64(5, field_names[2], ExpansionRatio);
}
if (hasCurrentDatabaseSize)
{
output.WriteInt64(6, field_names[0], CurrentDatabaseSize);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _eventFieldNames;
if (hasType)
{
output.WriteEnum(1, field_names[4], (int)Type, Type);
}
if (hasSumary)
{
output.WriteString(2, field_names[2], Sumary);
}
if (hasDetail)
{
output.WriteString(3, field_names[1], Detail);
}
if (hasTimestamp)
{
output.WriteUInt64(4, field_names[3], Timestamp);
}
if (hasBt)
{
output.WriteMessage(5, field_names[0], Bt);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _laidianCommandModelFieldNames;
if (hasMessageType)
{
output.WriteEnum(1, field_names[2], (int)MessageType, MessageType);
}
if (hasLaidianData)
{
output.WriteMessage(2, field_names[0], LaidianData);
}
if (hasResult)
{
output.WriteInt32(3, field_names[3], Result);
}
if (hasMessage)
{
output.WriteString(4, field_names[1], Message);
}
if (hasTerminal)
{
output.WriteString(5, field_names[4], Terminal);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _agentIdentityFieldNames;
if (hasAccountGUID)
{
output.WriteString(1, field_names[0], AccountGUID);
}
if (hasAppGUID)
{
output.WriteString(2, field_names[5], AppGUID);
}
if (hasClusterGUID)
{
output.WriteString(3, field_names[7], ClusterGUID);
}
if (hasTierGUID)
{
output.WriteString(4, field_names[11], TierGUID);
}
if (hasNodeGUID)
{
output.WriteString(5, field_names[9], NodeGUID);
}
if (hasAgentGUID)
{
output.WriteString(6, field_names[2], AgentGUID);
}
if (hasAccountID)
{
output.WriteUInt32(7, field_names[1], AccountID);
}
if (hasAppID)
{
output.WriteUInt32(8, field_names[6], AppID);
}
if (hasClusterID)
{
output.WriteUInt32(9, field_names[8], ClusterID);
}
if (hasTierID)
{
output.WriteUInt32(10, field_names[12], TierID);
}
if (hasNodeID)
{
output.WriteUInt32(11, field_names[10], NodeID);
}
if (hasAgentID)
{
output.WriteUInt32(12, field_names[3], AgentID);
}
if (hasAgentType)
{
output.WriteEnum(13, field_names[4], (int)AgentType, AgentType);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _healthCheckResponseFieldNames;
if (hasStatus)
{
output.WriteEnum(1, field_names[0], (int)Status, Status);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _protoHeartbeatEventFieldNames;
if (hasPayloadType)
{
output.WriteEnum(1, field_names[0], (int)PayloadType, PayloadType);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _authSessionTokenReplyFieldNames;
if (hasResultCode)
{
output.WriteEnum(1, field_names[0], (int)ResultCode, ResultCode);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _fooFieldNames;
if (Int32Value != 0)
{
output.WriteInt32(1, field_names[1], Int32Value);
}
if (EnumValue != global::Google.ProtocolBuffers.TestProtos.Foo.Types.NestedEnum.FOO)
{
output.WriteEnum(2, field_names[0], (int)EnumValue, EnumValue);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _phoneNumberFieldNames;
if (hasNumber)
{
output.WriteString(1, field_names[0], Number);
}
if (hasType)
{
output.WriteEnum(2, field_names[1], (int)Type, Type);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _programStatusFieldNames;
if (hasType)
{
output.WriteEnum(1, field_names[1], (int)Type, Type);
}
if (hasStrExtDesc)
{
output.WriteString(2, field_names[0], StrExtDesc);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _commonRespFieldNames;
if (hasCode)
{
output.WriteEnum(1, field_names[0], (int)Code, Code);
}
if (hasInfo)
{
output.WriteString(2, field_names[1], Info);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _upRevisionFieldNames;
if (hasValue)
{
output.WriteEnum(1, field_names[0], (int)Value, Value);
}
if (values_.Count > 0)
{
output.WriteEnumArray(2, field_names[1], values_);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _selectionFieldNames;
if (hasType)
{
output.WriteEnum(1, field_names[1], (int)Type, Type);
}
if (hasMatcher)
{
output.WriteString(2, field_names[0], Matcher);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _getAcctPropListReplyFieldNames;
if (hasResultCode)
{
output.WriteEnum(1, field_names[1], (int)ResultCode, ResultCode);
}
if (propList_.Count > 0)
{
output.WriteMessageArray(2, field_names[0], propList_);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _navigationTaskFieldNames;
if (hasLocation)
{
output.WriteMessage(1, field_names[0], Location);
}
if (hasOrientation)
{
output.WriteEnum(2, field_names[1], (int)Orientation, Orientation);
}
if (hasWaitTime)
{
output.WriteMessage(3, field_names[2], WaitTime);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _robotStatusFieldNames;
if (hasCapability)
{
output.WriteEnum(1, field_names[0], (int)Capability, Capability);
}
if (hasFunctionality)
{
output.WriteString(2, field_names[1], Functionality);
}
if (hasMetaData)
{
output.WriteString(3, field_names[2], MetaData);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _defeatMessageFieldNames;
if (hasType)
{
output.WriteEnum(1, field_names[2], (int)Type, Type);
}
if (hasCallMessage)
{
output.WriteMessage(2, field_names[1], CallMessage);
}
if (hasBackMessage)
{
output.WriteMessage(3, field_names[0], BackMessage);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _regularDataFieldNames;
if (hasTerminalId)
{
output.WriteInt64(1, field_names[8], TerminalId);
}
if (hasRegularCode)
{
output.WriteEnum(2, field_names[6], (int)RegularCode, RegularCode);
}
if (hasLastModifyDate)
{
output.WriteInt64(3, field_names[5], LastModifyDate);
}
if (hasSpeeding)
{
output.WriteMessage(4, field_names[7], Speeding);
}
if (hasInOutArea)
{
output.WriteMessage(5, field_names[4], InOutArea);
}
if (hasDriverTime)
{
output.WriteMessage(6, field_names[2], DriverTime);
}
if (hasDriverNotCard)
{
output.WriteMessage(7, field_names[1], DriverNotCard);
}
if (hasDoorOpenOutArea)
{
output.WriteMessage(8, field_names[0], DoorOpenOutArea);
}
if (hasDrivingBan)
{
output.WriteMessage(9, field_names[3], DrivingBan);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
int size = SerializedSize;
string[] field_names = _verifyProtocolReplyFieldNames;
if (hasResultCode)
{
output.WriteEnum(1, field_names[2], (int)ResultCode, ResultCode);
}
if (hasIv1)
{
output.WriteBytes(2, field_names[0], Iv1);
}
if (hasIv2)
{
output.WriteBytes(3, field_names[1], Iv2);
}
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)
{
int size = SerializedSize;
string[] field_names = _packetSpeedFieldNames;
if (hasType)
{
output.WriteEnum(1, field_names[2], (int)Type, Type);
}
if (string_.Count > 0)
{
output.WriteStringArray(2, field_names[1], string_);
}
if (float_.Count > 0)
{
output.WriteFloatArray(3, field_names[0], float_);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _protoErrorResFieldNames;
if (hasPayloadType)
{
output.WriteEnum(1, field_names[3], (int)PayloadType, PayloadType);
}
if (hasErrorCode)
{
output.WriteString(2, field_names[1], ErrorCode);
}
if (hasDescription)
{
output.WriteString(3, field_names[0], Description);
}
if (hasMaintenanceEndTimestamp)
{
output.WriteUInt64(4, field_names[2], MaintenanceEndTimestamp);
}
UnknownFields.WriteTo(output);
}
public override void WriteTo(pb::ICodedOutputStream output)
{
CalcSerializedSize();
string[] field_names = _businessTransactionFieldNames;
if (hasId)
{
output.WriteUInt32(1, field_names[0], Id);
}
if (hasName)
{
output.WriteString(2, field_names[2], Name);
}
if (hasType)
{
output.WriteEnum(3, field_names[3], (int)Type, Type);
}
if (hasInternalName)
{
output.WriteString(4, field_names[1], InternalName);
}
UnknownFields.WriteTo(output);
}