| // Generated by ProtoGen, Version=2.3.0.277, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48. DO NOT EDIT! | |
| using pb = global::Google.ProtocolBuffers; | |
| using pbc = global::Google.ProtocolBuffers.Collections; | |
| using pbd = global::Google.ProtocolBuffers.Descriptors; | |
| using scg = global::System.Collections.Generic; | |
| namespace Google.ProtocolBuffers.TestProtos { | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public static partial class UnitTestGoogleSpeedProtoFile { | |
| #region Extension registration | |
| public static void RegisterAllExtensions(pb::ExtensionRegistry registry) { | |
| } | |
| #endregion | |
| #region Static variables | |
| internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage1__Descriptor; | |
| internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage1, global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.Builder> internal__static_benchmarks_SpeedMessage1__FieldAccessorTable; | |
| internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage1SubMessage__Descriptor; | |
| internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage, global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder> internal__static_benchmarks_SpeedMessage1SubMessage__FieldAccessorTable; | |
| internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage2__Descriptor; | |
| internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Builder> internal__static_benchmarks_SpeedMessage2__FieldAccessorTable; | |
| internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage2_Group1__Descriptor; | |
| internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder> internal__static_benchmarks_SpeedMessage2_Group1__FieldAccessorTable; | |
| internal static pbd::MessageDescriptor internal__static_benchmarks_SpeedMessage2GroupedMessage__Descriptor; | |
| internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder> internal__static_benchmarks_SpeedMessage2GroupedMessage__FieldAccessorTable; | |
| #endregion | |
| #region Descriptor | |
| public static pbd::FileDescriptor Descriptor { | |
| get { return descriptor; } | |
| } | |
| private static pbd::FileDescriptor descriptor; | |
| static UnitTestGoogleSpeedProtoFile() { | |
| byte[] descriptorData = global::System.Convert.FromBase64String( | |
| "Ch5nb29nbGUvdGVzdC9nb29nbGVfc3BlZWQucHJvdG8SCmJlbmNobWFya3Ma" + | |
| "JGdvb2dsZS9wcm90b2J1Zi9jc2hhcnBfb3B0aW9ucy5wcm90byL4BgoNU3Bl" + | |
| "ZWRNZXNzYWdlMRIOCgZmaWVsZDEYASACKAkSDgoGZmllbGQ5GAkgASgJEg8K" + | |
| "B2ZpZWxkMTgYEiABKAkSFgoHZmllbGQ4MBhQIAEoCDoFZmFsc2USFQoHZmll" + | |
| "bGQ4MRhRIAEoCDoEdHJ1ZRIOCgZmaWVsZDIYAiACKAUSDgoGZmllbGQzGAMg" + | |
| "AigFEhEKCGZpZWxkMjgwGJgCIAEoBRIRCgZmaWVsZDYYBiABKAU6ATASDwoH" + | |
| "ZmllbGQyMhgWIAEoAxIOCgZmaWVsZDQYBCABKAkSDgoGZmllbGQ1GAUgAygG" + | |
| "EhYKB2ZpZWxkNTkYOyABKAg6BWZhbHNlEg4KBmZpZWxkNxgHIAEoCRIPCgdm" + | |
| "aWVsZDE2GBAgASgFEhQKCGZpZWxkMTMwGIIBIAEoBToBMBIVCgdmaWVsZDEy" + | |
| "GAwgASgIOgR0cnVlEhUKB2ZpZWxkMTcYESABKAg6BHRydWUSFQoHZmllbGQx" + | |
| "MxgNIAEoCDoEdHJ1ZRIVCgdmaWVsZDE0GA4gASgIOgR0cnVlEhMKCGZpZWxk" + | |
| "MTA0GGggASgFOgEwEhMKCGZpZWxkMTAwGGQgASgFOgEwEhMKCGZpZWxkMTAx" + | |
| "GGUgASgFOgEwEhAKCGZpZWxkMTAyGGYgASgJEhAKCGZpZWxkMTAzGGcgASgJ" + | |
| "EhIKB2ZpZWxkMjkYHSABKAU6ATASFgoHZmllbGQzMBgeIAEoCDoFZmFsc2US" + | |
| "EwoHZmllbGQ2MBg8IAEoBToCLTESFQoIZmllbGQyNzEYjwIgASgFOgItMRIV" + | |
| "CghmaWVsZDI3MhiQAiABKAU6Ai0xEhEKCGZpZWxkMTUwGJYBIAEoBRISCgdm" + | |
| "aWVsZDIzGBcgASgFOgEwEhYKB2ZpZWxkMjQYGCABKAg6BWZhbHNlEhIKB2Zp" + | |
| "ZWxkMjUYGSABKAU6ATASNAoHZmllbGQxNRgPIAEoCzIjLmJlbmNobWFya3Mu" + | |
| "U3BlZWRNZXNzYWdlMVN1Yk1lc3NhZ2USDwoHZmllbGQ3OBhOIAEoCBISCgdm" + | |
| "aWVsZDY3GEMgASgFOgEwEg8KB2ZpZWxkNjgYRCABKAUSFAoIZmllbGQxMjgY" + | |
| "gAEgASgFOgEwEigKCGZpZWxkMTI5GIEBIAEoCToVeHh4eHh4eHh4eHh4eHh4" + | |
| "eHh4eHh4EhQKCGZpZWxkMTMxGIMBIAEoBToBMCKiAwoXU3BlZWRNZXNzYWdl" + | |
| "MVN1Yk1lc3NhZ2USEQoGZmllbGQxGAEgASgFOgEwEhEKBmZpZWxkMhgCIAEo" + | |
| "BToBMBIRCgZmaWVsZDMYAyABKAU6ATASDwoHZmllbGQxNRgPIAEoCRIVCgdm" + | |
| "aWVsZDEyGAwgASgIOgR0cnVlEg8KB2ZpZWxkMTMYDSABKAMSDwoHZmllbGQx" + | |
| "NBgOIAEoAxIPCgdmaWVsZDE2GBAgASgFEhIKB2ZpZWxkMTkYEyABKAU6ATIS" + | |
| "FQoHZmllbGQyMBgUIAEoCDoEdHJ1ZRIVCgdmaWVsZDI4GBwgASgIOgR0cnVl" + | |
| "Eg8KB2ZpZWxkMjEYFSABKAYSDwoHZmllbGQyMhgWIAEoBRIWCgdmaWVsZDIz" + | |
| "GBcgASgIOgVmYWxzZRIYCghmaWVsZDIwNhjOASABKAg6BWZhbHNlEhEKCGZp" + | |
| "ZWxkMjAzGMsBIAEoBxIRCghmaWVsZDIwNBjMASABKAUSEQoIZmllbGQyMDUY" + | |
| "zQEgASgJEhEKCGZpZWxkMjA3GM8BIAEoBBIRCghmaWVsZDMwMBisAiABKAQi" + | |
| "ygcKDVNwZWVkTWVzc2FnZTISDgoGZmllbGQxGAEgASgJEg4KBmZpZWxkMxgD" + | |
| "IAEoAxIOCgZmaWVsZDQYBCABKAMSDwoHZmllbGQzMBgeIAEoAxIWCgdmaWVs" + | |
| "ZDc1GEsgASgIOgVmYWxzZRIOCgZmaWVsZDYYBiABKAkSDgoGZmllbGQyGAIg" + | |
| "ASgMEhIKB2ZpZWxkMjEYFSABKAU6ATASDwoHZmllbGQ3MRhHIAEoBRIPCgdm" + | |
| "aWVsZDI1GBkgASgCEhMKCGZpZWxkMTA5GG0gASgFOgEwEhQKCGZpZWxkMjEw" + | |
| "GNIBIAEoBToBMBIUCghmaWVsZDIxMRjTASABKAU6ATASFAoIZmllbGQyMTIY" + | |
| "1AEgASgFOgEwEhQKCGZpZWxkMjEzGNUBIAEoBToBMBIUCghmaWVsZDIxNhjY" + | |
| "ASABKAU6ATASFAoIZmllbGQyMTcY2QEgASgFOgEwEhQKCGZpZWxkMjE4GNoB" + | |
| "IAEoBToBMBIUCghmaWVsZDIyMBjcASABKAU6ATASFAoIZmllbGQyMjEY3QEg" + | |
| "ASgFOgEwEhQKCGZpZWxkMjIyGN4BIAEoAjoBMBIPCgdmaWVsZDYzGD8gASgF" + | |
| "EjAKBmdyb3VwMRgKIAMoCjIgLmJlbmNobWFya3MuU3BlZWRNZXNzYWdlMi5H" + | |
| "cm91cDESEQoIZmllbGQxMjgYgAEgAygJEhEKCGZpZWxkMTMxGIMBIAEoAxIQ" + | |
| "CghmaWVsZDEyNxh/IAMoCRIRCghmaWVsZDEyORiBASABKAUSEQoIZmllbGQx" + | |
| "MzAYggEgAygDEhgKCGZpZWxkMjA1GM0BIAEoCDoFZmFsc2USGAoIZmllbGQy" + | |
| "MDYYzgEgASgIOgVmYWxzZRrDAgoGR3JvdXAxEg8KB2ZpZWxkMTEYCyACKAIS" + | |
| "DwoHZmllbGQyNhgaIAEoAhIPCgdmaWVsZDEyGAwgASgJEg8KB2ZpZWxkMTMY" + | |
| "DSABKAkSDwoHZmllbGQxNBgOIAMoCRIPCgdmaWVsZDE1GA8gAigEEg4KBmZp" + | |
| "ZWxkNRgFIAEoBRIPCgdmaWVsZDI3GBsgASgJEg8KB2ZpZWxkMjgYHCABKAUS" + | |
| "DwoHZmllbGQyORgdIAEoCRIPCgdmaWVsZDE2GBAgASgJEg8KB2ZpZWxkMjIY" + | |
| "FiADKAkSDwoHZmllbGQ3MxhJIAMoBRISCgdmaWVsZDIwGBQgASgFOgEwEg8K" + | |
| "B2ZpZWxkMjQYGCABKAkSOAoHZmllbGQzMRgfIAEoCzInLmJlbmNobWFya3Mu" + | |
| "U3BlZWRNZXNzYWdlMkdyb3VwZWRNZXNzYWdlIt8BChtTcGVlZE1lc3NhZ2Uy" + | |
| "R3JvdXBlZE1lc3NhZ2USDgoGZmllbGQxGAEgASgCEg4KBmZpZWxkMhgCIAEo" + | |
| "AhIRCgZmaWVsZDMYAyABKAI6ATASDgoGZmllbGQ0GAQgASgIEg4KBmZpZWxk" + | |
| "NRgFIAEoCBIUCgZmaWVsZDYYBiABKAg6BHRydWUSFQoGZmllbGQ3GAcgASgI" + | |
| "OgVmYWxzZRIOCgZmaWVsZDgYCCABKAISDgoGZmllbGQ5GAkgASgIEg8KB2Zp" + | |
| "ZWxkMTAYCiABKAISDwoHZmllbGQxMRgLIAEoA0JTQgtHb29nbGVTcGVlZEgB" + | |
| "wj5BCiFHb29nbGUuUHJvdG9jb2xCdWZmZXJzLlRlc3RQcm90b3MSHFVuaXRU" + | |
| "ZXN0R29vZ2xlU3BlZWRQcm90b0ZpbGU="); | |
| pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { | |
| descriptor = root; | |
| internal__static_benchmarks_SpeedMessage1__Descriptor = Descriptor.MessageTypes[0]; | |
| internal__static_benchmarks_SpeedMessage1__FieldAccessorTable = | |
| new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage1, global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.Builder>(internal__static_benchmarks_SpeedMessage1__Descriptor, | |
| new string[] { "Field1", "Field9", "Field18", "Field80", "Field81", "Field2", "Field3", "Field280", "Field6", "Field22", "Field4", "Field5", "Field59", "Field7", "Field16", "Field130", "Field12", "Field17", "Field13", "Field14", "Field104", "Field100", "Field101", "Field102", "Field103", "Field29", "Field30", "Field60", "Field271", "Field272", "Field150", "Field23", "Field24", "Field25", "Field15", "Field78", "Field67", "Field68", "Field128", "Field129", "Field131", }); | |
| internal__static_benchmarks_SpeedMessage1SubMessage__Descriptor = Descriptor.MessageTypes[1]; | |
| internal__static_benchmarks_SpeedMessage1SubMessage__FieldAccessorTable = | |
| new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage, global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder>(internal__static_benchmarks_SpeedMessage1SubMessage__Descriptor, | |
| new string[] { "Field1", "Field2", "Field3", "Field15", "Field12", "Field13", "Field14", "Field16", "Field19", "Field20", "Field28", "Field21", "Field22", "Field23", "Field206", "Field203", "Field204", "Field205", "Field207", "Field300", }); | |
| internal__static_benchmarks_SpeedMessage2__Descriptor = Descriptor.MessageTypes[2]; | |
| internal__static_benchmarks_SpeedMessage2__FieldAccessorTable = | |
| new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Builder>(internal__static_benchmarks_SpeedMessage2__Descriptor, | |
| new string[] { "Field1", "Field3", "Field4", "Field30", "Field75", "Field6", "Field2", "Field21", "Field71", "Field25", "Field109", "Field210", "Field211", "Field212", "Field213", "Field216", "Field217", "Field218", "Field220", "Field221", "Field222", "Field63", "Group1", "Field128", "Field131", "Field127", "Field129", "Field130", "Field205", "Field206", }); | |
| internal__static_benchmarks_SpeedMessage2_Group1__Descriptor = internal__static_benchmarks_SpeedMessage2__Descriptor.NestedTypes[0]; | |
| internal__static_benchmarks_SpeedMessage2_Group1__FieldAccessorTable = | |
| new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder>(internal__static_benchmarks_SpeedMessage2_Group1__Descriptor, | |
| new string[] { "Field11", "Field26", "Field12", "Field13", "Field14", "Field15", "Field5", "Field27", "Field28", "Field29", "Field16", "Field22", "Field73", "Field20", "Field24", "Field31", }); | |
| internal__static_benchmarks_SpeedMessage2GroupedMessage__Descriptor = Descriptor.MessageTypes[3]; | |
| internal__static_benchmarks_SpeedMessage2GroupedMessage__FieldAccessorTable = | |
| new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder>(internal__static_benchmarks_SpeedMessage2GroupedMessage__Descriptor, | |
| new string[] { "Field1", "Field2", "Field3", "Field4", "Field5", "Field6", "Field7", "Field8", "Field9", "Field10", "Field11", }); | |
| pb::ExtensionRegistry registry = pb::ExtensionRegistry.CreateInstance(); | |
| RegisterAllExtensions(registry); | |
| global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.RegisterAllExtensions(registry); | |
| return registry; | |
| }; | |
| pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, | |
| new pbd::FileDescriptor[] { | |
| global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, | |
| }, assigner); | |
| } | |
| #endregion | |
| } | |
| #region Messages | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class SpeedMessage1 : pb::GeneratedMessage<SpeedMessage1, SpeedMessage1.Builder> { | |
| private static readonly SpeedMessage1 defaultInstance = new Builder().BuildPartial(); | |
| public static SpeedMessage1 DefaultInstance { | |
| get { return defaultInstance; } | |
| } | |
| public override SpeedMessage1 DefaultInstanceForType { | |
| get { return defaultInstance; } | |
| } | |
| protected override SpeedMessage1 ThisMessage { | |
| get { return this; } | |
| } | |
| public static pbd::MessageDescriptor Descriptor { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage1__Descriptor; } | |
| } | |
| protected override pb::FieldAccess.FieldAccessorTable<SpeedMessage1, SpeedMessage1.Builder> InternalFieldAccessors { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage1__FieldAccessorTable; } | |
| } | |
| public const int Field1FieldNumber = 1; | |
| private bool hasField1; | |
| private string field1_ = ""; | |
| public bool HasField1 { | |
| get { return hasField1; } | |
| } | |
| public string Field1 { | |
| get { return field1_; } | |
| } | |
| public const int Field9FieldNumber = 9; | |
| private bool hasField9; | |
| private string field9_ = ""; | |
| public bool HasField9 { | |
| get { return hasField9; } | |
| } | |
| public string Field9 { | |
| get { return field9_; } | |
| } | |
| public const int Field18FieldNumber = 18; | |
| private bool hasField18; | |
| private string field18_ = ""; | |
| public bool HasField18 { | |
| get { return hasField18; } | |
| } | |
| public string Field18 { | |
| get { return field18_; } | |
| } | |
| public const int Field80FieldNumber = 80; | |
| private bool hasField80; | |
| private bool field80_ = false; | |
| public bool HasField80 { | |
| get { return hasField80; } | |
| } | |
| public bool Field80 { | |
| get { return field80_; } | |
| } | |
| public const int Field81FieldNumber = 81; | |
| private bool hasField81; | |
| private bool field81_ = true; | |
| public bool HasField81 { | |
| get { return hasField81; } | |
| } | |
| public bool Field81 { | |
| get { return field81_; } | |
| } | |
| public const int Field2FieldNumber = 2; | |
| private bool hasField2; | |
| private int field2_ = 0; | |
| public bool HasField2 { | |
| get { return hasField2; } | |
| } | |
| public int Field2 { | |
| get { return field2_; } | |
| } | |
| public const int Field3FieldNumber = 3; | |
| private bool hasField3; | |
| private int field3_ = 0; | |
| public bool HasField3 { | |
| get { return hasField3; } | |
| } | |
| public int Field3 { | |
| get { return field3_; } | |
| } | |
| public const int Field280FieldNumber = 280; | |
| private bool hasField280; | |
| private int field280_ = 0; | |
| public bool HasField280 { | |
| get { return hasField280; } | |
| } | |
| public int Field280 { | |
| get { return field280_; } | |
| } | |
| public const int Field6FieldNumber = 6; | |
| private bool hasField6; | |
| private int field6_ = 0; | |
| public bool HasField6 { | |
| get { return hasField6; } | |
| } | |
| public int Field6 { | |
| get { return field6_; } | |
| } | |
| public const int Field22FieldNumber = 22; | |
| private bool hasField22; | |
| private long field22_ = 0L; | |
| public bool HasField22 { | |
| get { return hasField22; } | |
| } | |
| public long Field22 { | |
| get { return field22_; } | |
| } | |
| public const int Field4FieldNumber = 4; | |
| private bool hasField4; | |
| private string field4_ = ""; | |
| public bool HasField4 { | |
| get { return hasField4; } | |
| } | |
| public string Field4 { | |
| get { return field4_; } | |
| } | |
| public const int Field5FieldNumber = 5; | |
| private pbc::PopsicleList<ulong> field5_ = new pbc::PopsicleList<ulong>(); | |
| [global::System.CLSCompliant(false)] | |
| public scg::IList<ulong> Field5List { | |
| get { return pbc::Lists.AsReadOnly(field5_); } | |
| } | |
| public int Field5Count { | |
| get { return field5_.Count; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong GetField5(int index) { | |
| return field5_[index]; | |
| } | |
| public const int Field59FieldNumber = 59; | |
| private bool hasField59; | |
| private bool field59_ = false; | |
| public bool HasField59 { | |
| get { return hasField59; } | |
| } | |
| public bool Field59 { | |
| get { return field59_; } | |
| } | |
| public const int Field7FieldNumber = 7; | |
| private bool hasField7; | |
| private string field7_ = ""; | |
| public bool HasField7 { | |
| get { return hasField7; } | |
| } | |
| public string Field7 { | |
| get { return field7_; } | |
| } | |
| public const int Field16FieldNumber = 16; | |
| private bool hasField16; | |
| private int field16_ = 0; | |
| public bool HasField16 { | |
| get { return hasField16; } | |
| } | |
| public int Field16 { | |
| get { return field16_; } | |
| } | |
| public const int Field130FieldNumber = 130; | |
| private bool hasField130; | |
| private int field130_ = 0; | |
| public bool HasField130 { | |
| get { return hasField130; } | |
| } | |
| public int Field130 { | |
| get { return field130_; } | |
| } | |
| public const int Field12FieldNumber = 12; | |
| private bool hasField12; | |
| private bool field12_ = true; | |
| public bool HasField12 { | |
| get { return hasField12; } | |
| } | |
| public bool Field12 { | |
| get { return field12_; } | |
| } | |
| public const int Field17FieldNumber = 17; | |
| private bool hasField17; | |
| private bool field17_ = true; | |
| public bool HasField17 { | |
| get { return hasField17; } | |
| } | |
| public bool Field17 { | |
| get { return field17_; } | |
| } | |
| public const int Field13FieldNumber = 13; | |
| private bool hasField13; | |
| private bool field13_ = true; | |
| public bool HasField13 { | |
| get { return hasField13; } | |
| } | |
| public bool Field13 { | |
| get { return field13_; } | |
| } | |
| public const int Field14FieldNumber = 14; | |
| private bool hasField14; | |
| private bool field14_ = true; | |
| public bool HasField14 { | |
| get { return hasField14; } | |
| } | |
| public bool Field14 { | |
| get { return field14_; } | |
| } | |
| public const int Field104FieldNumber = 104; | |
| private bool hasField104; | |
| private int field104_ = 0; | |
| public bool HasField104 { | |
| get { return hasField104; } | |
| } | |
| public int Field104 { | |
| get { return field104_; } | |
| } | |
| public const int Field100FieldNumber = 100; | |
| private bool hasField100; | |
| private int field100_ = 0; | |
| public bool HasField100 { | |
| get { return hasField100; } | |
| } | |
| public int Field100 { | |
| get { return field100_; } | |
| } | |
| public const int Field101FieldNumber = 101; | |
| private bool hasField101; | |
| private int field101_ = 0; | |
| public bool HasField101 { | |
| get { return hasField101; } | |
| } | |
| public int Field101 { | |
| get { return field101_; } | |
| } | |
| public const int Field102FieldNumber = 102; | |
| private bool hasField102; | |
| private string field102_ = ""; | |
| public bool HasField102 { | |
| get { return hasField102; } | |
| } | |
| public string Field102 { | |
| get { return field102_; } | |
| } | |
| public const int Field103FieldNumber = 103; | |
| private bool hasField103; | |
| private string field103_ = ""; | |
| public bool HasField103 { | |
| get { return hasField103; } | |
| } | |
| public string Field103 { | |
| get { return field103_; } | |
| } | |
| public const int Field29FieldNumber = 29; | |
| private bool hasField29; | |
| private int field29_ = 0; | |
| public bool HasField29 { | |
| get { return hasField29; } | |
| } | |
| public int Field29 { | |
| get { return field29_; } | |
| } | |
| public const int Field30FieldNumber = 30; | |
| private bool hasField30; | |
| private bool field30_ = false; | |
| public bool HasField30 { | |
| get { return hasField30; } | |
| } | |
| public bool Field30 { | |
| get { return field30_; } | |
| } | |
| public const int Field60FieldNumber = 60; | |
| private bool hasField60; | |
| private int field60_ = -1; | |
| public bool HasField60 { | |
| get { return hasField60; } | |
| } | |
| public int Field60 { | |
| get { return field60_; } | |
| } | |
| public const int Field271FieldNumber = 271; | |
| private bool hasField271; | |
| private int field271_ = -1; | |
| public bool HasField271 { | |
| get { return hasField271; } | |
| } | |
| public int Field271 { | |
| get { return field271_; } | |
| } | |
| public const int Field272FieldNumber = 272; | |
| private bool hasField272; | |
| private int field272_ = -1; | |
| public bool HasField272 { | |
| get { return hasField272; } | |
| } | |
| public int Field272 { | |
| get { return field272_; } | |
| } | |
| public const int Field150FieldNumber = 150; | |
| private bool hasField150; | |
| private int field150_ = 0; | |
| public bool HasField150 { | |
| get { return hasField150; } | |
| } | |
| public int Field150 { | |
| get { return field150_; } | |
| } | |
| public const int Field23FieldNumber = 23; | |
| private bool hasField23; | |
| private int field23_ = 0; | |
| public bool HasField23 { | |
| get { return hasField23; } | |
| } | |
| public int Field23 { | |
| get { return field23_; } | |
| } | |
| public const int Field24FieldNumber = 24; | |
| private bool hasField24; | |
| private bool field24_ = false; | |
| public bool HasField24 { | |
| get { return hasField24; } | |
| } | |
| public bool Field24 { | |
| get { return field24_; } | |
| } | |
| public const int Field25FieldNumber = 25; | |
| private bool hasField25; | |
| private int field25_ = 0; | |
| public bool HasField25 { | |
| get { return hasField25; } | |
| } | |
| public int Field25 { | |
| get { return field25_; } | |
| } | |
| public const int Field15FieldNumber = 15; | |
| private bool hasField15; | |
| private global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage field15_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance; | |
| public bool HasField15 { | |
| get { return hasField15; } | |
| } | |
| public global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage Field15 { | |
| get { return field15_; } | |
| } | |
| public const int Field78FieldNumber = 78; | |
| private bool hasField78; | |
| private bool field78_ = false; | |
| public bool HasField78 { | |
| get { return hasField78; } | |
| } | |
| public bool Field78 { | |
| get { return field78_; } | |
| } | |
| public const int Field67FieldNumber = 67; | |
| private bool hasField67; | |
| private int field67_ = 0; | |
| public bool HasField67 { | |
| get { return hasField67; } | |
| } | |
| public int Field67 { | |
| get { return field67_; } | |
| } | |
| public const int Field68FieldNumber = 68; | |
| private bool hasField68; | |
| private int field68_ = 0; | |
| public bool HasField68 { | |
| get { return hasField68; } | |
| } | |
| public int Field68 { | |
| get { return field68_; } | |
| } | |
| public const int Field128FieldNumber = 128; | |
| private bool hasField128; | |
| private int field128_ = 0; | |
| public bool HasField128 { | |
| get { return hasField128; } | |
| } | |
| public int Field128 { | |
| get { return field128_; } | |
| } | |
| public const int Field129FieldNumber = 129; | |
| private bool hasField129; | |
| private string field129_ = "xxxxxxxxxxxxxxxxxxxxx"; | |
| public bool HasField129 { | |
| get { return hasField129; } | |
| } | |
| public string Field129 { | |
| get { return field129_; } | |
| } | |
| public const int Field131FieldNumber = 131; | |
| private bool hasField131; | |
| private int field131_ = 0; | |
| public bool HasField131 { | |
| get { return hasField131; } | |
| } | |
| public int Field131 { | |
| get { return field131_; } | |
| } | |
| public override bool IsInitialized { | |
| get { | |
| if (!hasField1) return false; | |
| if (!hasField2) return false; | |
| if (!hasField3) return false; | |
| return true; | |
| } | |
| } | |
| public override void WriteTo(pb::CodedOutputStream output) { | |
| int size = SerializedSize; | |
| if (HasField1) { | |
| output.WriteString(1, "field1", Field1); | |
| } | |
| if (HasField2) { | |
| output.WriteInt32(2, "field2", Field2); | |
| } | |
| if (HasField3) { | |
| output.WriteInt32(3, "field3", Field3); | |
| } | |
| if (HasField4) { | |
| output.WriteString(4, "field4", Field4); | |
| } | |
| if (field5_.Count > 0) { | |
| output.WriteArray(pbd::FieldType.Fixed64, 5, "field5", field5_); | |
| } | |
| if (HasField6) { | |
| output.WriteInt32(6, "field6", Field6); | |
| } | |
| if (HasField7) { | |
| output.WriteString(7, "field7", Field7); | |
| } | |
| if (HasField9) { | |
| output.WriteString(9, "field9", Field9); | |
| } | |
| if (HasField12) { | |
| output.WriteBool(12, "field12", Field12); | |
| } | |
| if (HasField13) { | |
| output.WriteBool(13, "field13", Field13); | |
| } | |
| if (HasField14) { | |
| output.WriteBool(14, "field14", Field14); | |
| } | |
| if (HasField15) { | |
| output.WriteMessage(15, "field15", Field15); | |
| } | |
| if (HasField16) { | |
| output.WriteInt32(16, "field16", Field16); | |
| } | |
| if (HasField17) { | |
| output.WriteBool(17, "field17", Field17); | |
| } | |
| if (HasField18) { | |
| output.WriteString(18, "field18", Field18); | |
| } | |
| if (HasField22) { | |
| output.WriteInt64(22, "field22", Field22); | |
| } | |
| if (HasField23) { | |
| output.WriteInt32(23, "field23", Field23); | |
| } | |
| if (HasField24) { | |
| output.WriteBool(24, "field24", Field24); | |
| } | |
| if (HasField25) { | |
| output.WriteInt32(25, "field25", Field25); | |
| } | |
| if (HasField29) { | |
| output.WriteInt32(29, "field29", Field29); | |
| } | |
| if (HasField30) { | |
| output.WriteBool(30, "field30", Field30); | |
| } | |
| if (HasField59) { | |
| output.WriteBool(59, "field59", Field59); | |
| } | |
| if (HasField60) { | |
| output.WriteInt32(60, "field60", Field60); | |
| } | |
| if (HasField67) { | |
| output.WriteInt32(67, "field67", Field67); | |
| } | |
| if (HasField68) { | |
| output.WriteInt32(68, "field68", Field68); | |
| } | |
| if (HasField78) { | |
| output.WriteBool(78, "field78", Field78); | |
| } | |
| if (HasField80) { | |
| output.WriteBool(80, "field80", Field80); | |
| } | |
| if (HasField81) { | |
| output.WriteBool(81, "field81", Field81); | |
| } | |
| if (HasField100) { | |
| output.WriteInt32(100, "field100", Field100); | |
| } | |
| if (HasField101) { | |
| output.WriteInt32(101, "field101", Field101); | |
| } | |
| if (HasField102) { | |
| output.WriteString(102, "field102", Field102); | |
| } | |
| if (HasField103) { | |
| output.WriteString(103, "field103", Field103); | |
| } | |
| if (HasField104) { | |
| output.WriteInt32(104, "field104", Field104); | |
| } | |
| if (HasField128) { | |
| output.WriteInt32(128, "field128", Field128); | |
| } | |
| if (HasField129) { | |
| output.WriteString(129, "field129", Field129); | |
| } | |
| if (HasField130) { | |
| output.WriteInt32(130, "field130", Field130); | |
| } | |
| if (HasField131) { | |
| output.WriteInt32(131, "field131", Field131); | |
| } | |
| if (HasField150) { | |
| output.WriteInt32(150, "field150", Field150); | |
| } | |
| if (HasField271) { | |
| output.WriteInt32(271, "field271", Field271); | |
| } | |
| if (HasField272) { | |
| output.WriteInt32(272, "field272", Field272); | |
| } | |
| if (HasField280) { | |
| output.WriteInt32(280, "field280", Field280); | |
| } | |
| UnknownFields.WriteTo(output); | |
| } | |
| private int memoizedSerializedSize = -1; | |
| public override int SerializedSize { | |
| get { | |
| int size = memoizedSerializedSize; | |
| if (size != -1) return size; | |
| size = 0; | |
| if (HasField1) { | |
| size += pb::CodedOutputStream.ComputeStringSize(1, Field1); | |
| } | |
| if (HasField9) { | |
| size += pb::CodedOutputStream.ComputeStringSize(9, Field9); | |
| } | |
| if (HasField18) { | |
| size += pb::CodedOutputStream.ComputeStringSize(18, Field18); | |
| } | |
| if (HasField80) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(80, Field80); | |
| } | |
| if (HasField81) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(81, Field81); | |
| } | |
| if (HasField2) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(2, Field2); | |
| } | |
| if (HasField3) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(3, Field3); | |
| } | |
| if (HasField280) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(280, Field280); | |
| } | |
| if (HasField6) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(6, Field6); | |
| } | |
| if (HasField22) { | |
| size += pb::CodedOutputStream.ComputeInt64Size(22, Field22); | |
| } | |
| if (HasField4) { | |
| size += pb::CodedOutputStream.ComputeStringSize(4, Field4); | |
| } | |
| { | |
| int dataSize = 0; | |
| dataSize = 8 * field5_.Count; | |
| size += dataSize; | |
| size += 1 * field5_.Count; | |
| } | |
| if (HasField59) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(59, Field59); | |
| } | |
| if (HasField7) { | |
| size += pb::CodedOutputStream.ComputeStringSize(7, Field7); | |
| } | |
| if (HasField16) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(16, Field16); | |
| } | |
| if (HasField130) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(130, Field130); | |
| } | |
| if (HasField12) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(12, Field12); | |
| } | |
| if (HasField17) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(17, Field17); | |
| } | |
| if (HasField13) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(13, Field13); | |
| } | |
| if (HasField14) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(14, Field14); | |
| } | |
| if (HasField104) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(104, Field104); | |
| } | |
| if (HasField100) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(100, Field100); | |
| } | |
| if (HasField101) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(101, Field101); | |
| } | |
| if (HasField102) { | |
| size += pb::CodedOutputStream.ComputeStringSize(102, Field102); | |
| } | |
| if (HasField103) { | |
| size += pb::CodedOutputStream.ComputeStringSize(103, Field103); | |
| } | |
| if (HasField29) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(29, Field29); | |
| } | |
| if (HasField30) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(30, Field30); | |
| } | |
| if (HasField60) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(60, Field60); | |
| } | |
| if (HasField271) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(271, Field271); | |
| } | |
| if (HasField272) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(272, Field272); | |
| } | |
| if (HasField150) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(150, Field150); | |
| } | |
| if (HasField23) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(23, Field23); | |
| } | |
| if (HasField24) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(24, Field24); | |
| } | |
| if (HasField25) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(25, Field25); | |
| } | |
| if (HasField15) { | |
| size += pb::CodedOutputStream.ComputeMessageSize(15, Field15); | |
| } | |
| if (HasField78) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(78, Field78); | |
| } | |
| if (HasField67) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(67, Field67); | |
| } | |
| if (HasField68) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(68, Field68); | |
| } | |
| if (HasField128) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(128, Field128); | |
| } | |
| if (HasField129) { | |
| size += pb::CodedOutputStream.ComputeStringSize(129, Field129); | |
| } | |
| if (HasField131) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(131, Field131); | |
| } | |
| size += UnknownFields.SerializedSize; | |
| memoizedSerializedSize = size; | |
| return size; | |
| } | |
| } | |
| public static SpeedMessage1 ParseFrom(pb::ByteString data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static SpeedMessage1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage1 ParseFrom(byte[] data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static SpeedMessage1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage1 ParseFrom(global::System.IO.Stream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static SpeedMessage1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage1 ParseDelimitedFrom(global::System.IO.Stream input) { | |
| return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | |
| } | |
| public static SpeedMessage1 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | |
| } | |
| public static SpeedMessage1 ParseFrom(pb::CodedInputStream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static SpeedMessage1 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static Builder CreateBuilder() { return new Builder(); } | |
| public override Builder ToBuilder() { return CreateBuilder(this); } | |
| public override Builder CreateBuilderForType() { return new Builder(); } | |
| public static Builder CreateBuilder(SpeedMessage1 prototype) { | |
| return (Builder) new Builder().MergeFrom(prototype); | |
| } | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class Builder : pb::GeneratedBuilder<SpeedMessage1, Builder> { | |
| protected override Builder ThisBuilder { | |
| get { return this; } | |
| } | |
| public Builder() {} | |
| SpeedMessage1 result = new SpeedMessage1(); | |
| protected override SpeedMessage1 MessageBeingBuilt { | |
| get { return result; } | |
| } | |
| public override Builder Clear() { | |
| result = new SpeedMessage1(); | |
| return this; | |
| } | |
| public override Builder Clone() { | |
| return new Builder().MergeFrom(result); | |
| } | |
| public override pbd::MessageDescriptor DescriptorForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.Descriptor; } | |
| } | |
| public override SpeedMessage1 DefaultInstanceForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.DefaultInstance; } | |
| } | |
| public override SpeedMessage1 BuildPartial() { | |
| if (result == null) { | |
| throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | |
| } | |
| result.field5_.MakeReadOnly(); | |
| SpeedMessage1 returnMe = result; | |
| result = null; | |
| return returnMe; | |
| } | |
| public override Builder MergeFrom(pb::IMessage other) { | |
| if (other is SpeedMessage1) { | |
| return MergeFrom((SpeedMessage1) other); | |
| } else { | |
| base.MergeFrom(other); | |
| return this; | |
| } | |
| } | |
| public override Builder MergeFrom(SpeedMessage1 other) { | |
| if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.DefaultInstance) return this; | |
| if (other.HasField1) { | |
| Field1 = other.Field1; | |
| } | |
| if (other.HasField9) { | |
| Field9 = other.Field9; | |
| } | |
| if (other.HasField18) { | |
| Field18 = other.Field18; | |
| } | |
| if (other.HasField80) { | |
| Field80 = other.Field80; | |
| } | |
| if (other.HasField81) { | |
| Field81 = other.Field81; | |
| } | |
| if (other.HasField2) { | |
| Field2 = other.Field2; | |
| } | |
| if (other.HasField3) { | |
| Field3 = other.Field3; | |
| } | |
| if (other.HasField280) { | |
| Field280 = other.Field280; | |
| } | |
| if (other.HasField6) { | |
| Field6 = other.Field6; | |
| } | |
| if (other.HasField22) { | |
| Field22 = other.Field22; | |
| } | |
| if (other.HasField4) { | |
| Field4 = other.Field4; | |
| } | |
| if (other.field5_.Count != 0) { | |
| base.AddRange(other.field5_, result.field5_); | |
| } | |
| if (other.HasField59) { | |
| Field59 = other.Field59; | |
| } | |
| if (other.HasField7) { | |
| Field7 = other.Field7; | |
| } | |
| if (other.HasField16) { | |
| Field16 = other.Field16; | |
| } | |
| if (other.HasField130) { | |
| Field130 = other.Field130; | |
| } | |
| if (other.HasField12) { | |
| Field12 = other.Field12; | |
| } | |
| if (other.HasField17) { | |
| Field17 = other.Field17; | |
| } | |
| if (other.HasField13) { | |
| Field13 = other.Field13; | |
| } | |
| if (other.HasField14) { | |
| Field14 = other.Field14; | |
| } | |
| if (other.HasField104) { | |
| Field104 = other.Field104; | |
| } | |
| if (other.HasField100) { | |
| Field100 = other.Field100; | |
| } | |
| if (other.HasField101) { | |
| Field101 = other.Field101; | |
| } | |
| if (other.HasField102) { | |
| Field102 = other.Field102; | |
| } | |
| if (other.HasField103) { | |
| Field103 = other.Field103; | |
| } | |
| if (other.HasField29) { | |
| Field29 = other.Field29; | |
| } | |
| if (other.HasField30) { | |
| Field30 = other.Field30; | |
| } | |
| if (other.HasField60) { | |
| Field60 = other.Field60; | |
| } | |
| if (other.HasField271) { | |
| Field271 = other.Field271; | |
| } | |
| if (other.HasField272) { | |
| Field272 = other.Field272; | |
| } | |
| if (other.HasField150) { | |
| Field150 = other.Field150; | |
| } | |
| if (other.HasField23) { | |
| Field23 = other.Field23; | |
| } | |
| if (other.HasField24) { | |
| Field24 = other.Field24; | |
| } | |
| if (other.HasField25) { | |
| Field25 = other.Field25; | |
| } | |
| if (other.HasField15) { | |
| MergeField15(other.Field15); | |
| } | |
| if (other.HasField78) { | |
| Field78 = other.Field78; | |
| } | |
| if (other.HasField67) { | |
| Field67 = other.Field67; | |
| } | |
| if (other.HasField68) { | |
| Field68 = other.Field68; | |
| } | |
| if (other.HasField128) { | |
| Field128 = other.Field128; | |
| } | |
| if (other.HasField129) { | |
| Field129 = other.Field129; | |
| } | |
| if (other.HasField131) { | |
| Field131 = other.Field131; | |
| } | |
| this.MergeUnknownFields(other.UnknownFields); | |
| return this; | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input) { | |
| return MergeFrom(input, pb::ExtensionRegistry.Empty); | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| pb::UnknownFieldSet.Builder unknownFields = null; | |
| while (true) { | |
| uint tag = input.ReadTag(); | |
| switch (tag) { | |
| case 0: { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| default: { | |
| if (pb::WireFormat.IsEndGroupTag(tag)) { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| if (unknownFields == null) { | |
| unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | |
| } | |
| ParseUnknownField(input, unknownFields, extensionRegistry, tag); | |
| break; | |
| } | |
| case 10: { | |
| Field1 = input.ReadString(); | |
| break; | |
| } | |
| case 16: { | |
| Field2 = input.ReadInt32(); | |
| break; | |
| } | |
| case 24: { | |
| Field3 = input.ReadInt32(); | |
| break; | |
| } | |
| case 34: { | |
| Field4 = input.ReadString(); | |
| break; | |
| } | |
| case 41: { | |
| AddField5(input.ReadFixed64()); | |
| break; | |
| } | |
| case 48: { | |
| Field6 = input.ReadInt32(); | |
| break; | |
| } | |
| case 58: { | |
| Field7 = input.ReadString(); | |
| break; | |
| } | |
| case 74: { | |
| Field9 = input.ReadString(); | |
| break; | |
| } | |
| case 96: { | |
| Field12 = input.ReadBool(); | |
| break; | |
| } | |
| case 104: { | |
| Field13 = input.ReadBool(); | |
| break; | |
| } | |
| case 112: { | |
| Field14 = input.ReadBool(); | |
| break; | |
| } | |
| case 122: { | |
| global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.CreateBuilder(); | |
| if (HasField15) { | |
| subBuilder.MergeFrom(Field15); | |
| } | |
| input.ReadMessage(subBuilder, extensionRegistry); | |
| Field15 = subBuilder.BuildPartial(); | |
| break; | |
| } | |
| case 128: { | |
| Field16 = input.ReadInt32(); | |
| break; | |
| } | |
| case 136: { | |
| Field17 = input.ReadBool(); | |
| break; | |
| } | |
| case 146: { | |
| Field18 = input.ReadString(); | |
| break; | |
| } | |
| case 176: { | |
| Field22 = input.ReadInt64(); | |
| break; | |
| } | |
| case 184: { | |
| Field23 = input.ReadInt32(); | |
| break; | |
| } | |
| case 192: { | |
| Field24 = input.ReadBool(); | |
| break; | |
| } | |
| case 200: { | |
| Field25 = input.ReadInt32(); | |
| break; | |
| } | |
| case 232: { | |
| Field29 = input.ReadInt32(); | |
| break; | |
| } | |
| case 240: { | |
| Field30 = input.ReadBool(); | |
| break; | |
| } | |
| case 472: { | |
| Field59 = input.ReadBool(); | |
| break; | |
| } | |
| case 480: { | |
| Field60 = input.ReadInt32(); | |
| break; | |
| } | |
| case 536: { | |
| Field67 = input.ReadInt32(); | |
| break; | |
| } | |
| case 544: { | |
| Field68 = input.ReadInt32(); | |
| break; | |
| } | |
| case 624: { | |
| Field78 = input.ReadBool(); | |
| break; | |
| } | |
| case 640: { | |
| Field80 = input.ReadBool(); | |
| break; | |
| } | |
| case 648: { | |
| Field81 = input.ReadBool(); | |
| break; | |
| } | |
| case 800: { | |
| Field100 = input.ReadInt32(); | |
| break; | |
| } | |
| case 808: { | |
| Field101 = input.ReadInt32(); | |
| break; | |
| } | |
| case 818: { | |
| Field102 = input.ReadString(); | |
| break; | |
| } | |
| case 826: { | |
| Field103 = input.ReadString(); | |
| break; | |
| } | |
| case 832: { | |
| Field104 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1024: { | |
| Field128 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1034: { | |
| Field129 = input.ReadString(); | |
| break; | |
| } | |
| case 1040: { | |
| Field130 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1048: { | |
| Field131 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1200: { | |
| Field150 = input.ReadInt32(); | |
| break; | |
| } | |
| case 2168: { | |
| Field271 = input.ReadInt32(); | |
| break; | |
| } | |
| case 2176: { | |
| Field272 = input.ReadInt32(); | |
| break; | |
| } | |
| case 2240: { | |
| Field280 = input.ReadInt32(); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| public bool HasField1 { | |
| get { return result.HasField1; } | |
| } | |
| public string Field1 { | |
| get { return result.Field1; } | |
| set { SetField1(value); } | |
| } | |
| public Builder SetField1(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField1 = true; | |
| result.field1_ = value; | |
| return this; | |
| } | |
| public Builder ClearField1() { | |
| result.hasField1 = false; | |
| result.field1_ = ""; | |
| return this; | |
| } | |
| public bool HasField9 { | |
| get { return result.HasField9; } | |
| } | |
| public string Field9 { | |
| get { return result.Field9; } | |
| set { SetField9(value); } | |
| } | |
| public Builder SetField9(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField9 = true; | |
| result.field9_ = value; | |
| return this; | |
| } | |
| public Builder ClearField9() { | |
| result.hasField9 = false; | |
| result.field9_ = ""; | |
| return this; | |
| } | |
| public bool HasField18 { | |
| get { return result.HasField18; } | |
| } | |
| public string Field18 { | |
| get { return result.Field18; } | |
| set { SetField18(value); } | |
| } | |
| public Builder SetField18(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField18 = true; | |
| result.field18_ = value; | |
| return this; | |
| } | |
| public Builder ClearField18() { | |
| result.hasField18 = false; | |
| result.field18_ = ""; | |
| return this; | |
| } | |
| public bool HasField80 { | |
| get { return result.HasField80; } | |
| } | |
| public bool Field80 { | |
| get { return result.Field80; } | |
| set { SetField80(value); } | |
| } | |
| public Builder SetField80(bool value) { | |
| result.hasField80 = true; | |
| result.field80_ = value; | |
| return this; | |
| } | |
| public Builder ClearField80() { | |
| result.hasField80 = false; | |
| result.field80_ = false; | |
| return this; | |
| } | |
| public bool HasField81 { | |
| get { return result.HasField81; } | |
| } | |
| public bool Field81 { | |
| get { return result.Field81; } | |
| set { SetField81(value); } | |
| } | |
| public Builder SetField81(bool value) { | |
| result.hasField81 = true; | |
| result.field81_ = value; | |
| return this; | |
| } | |
| public Builder ClearField81() { | |
| result.hasField81 = false; | |
| result.field81_ = true; | |
| return this; | |
| } | |
| public bool HasField2 { | |
| get { return result.HasField2; } | |
| } | |
| public int Field2 { | |
| get { return result.Field2; } | |
| set { SetField2(value); } | |
| } | |
| public Builder SetField2(int value) { | |
| result.hasField2 = true; | |
| result.field2_ = value; | |
| return this; | |
| } | |
| public Builder ClearField2() { | |
| result.hasField2 = false; | |
| result.field2_ = 0; | |
| return this; | |
| } | |
| public bool HasField3 { | |
| get { return result.HasField3; } | |
| } | |
| public int Field3 { | |
| get { return result.Field3; } | |
| set { SetField3(value); } | |
| } | |
| public Builder SetField3(int value) { | |
| result.hasField3 = true; | |
| result.field3_ = value; | |
| return this; | |
| } | |
| public Builder ClearField3() { | |
| result.hasField3 = false; | |
| result.field3_ = 0; | |
| return this; | |
| } | |
| public bool HasField280 { | |
| get { return result.HasField280; } | |
| } | |
| public int Field280 { | |
| get { return result.Field280; } | |
| set { SetField280(value); } | |
| } | |
| public Builder SetField280(int value) { | |
| result.hasField280 = true; | |
| result.field280_ = value; | |
| return this; | |
| } | |
| public Builder ClearField280() { | |
| result.hasField280 = false; | |
| result.field280_ = 0; | |
| return this; | |
| } | |
| public bool HasField6 { | |
| get { return result.HasField6; } | |
| } | |
| public int Field6 { | |
| get { return result.Field6; } | |
| set { SetField6(value); } | |
| } | |
| public Builder SetField6(int value) { | |
| result.hasField6 = true; | |
| result.field6_ = value; | |
| return this; | |
| } | |
| public Builder ClearField6() { | |
| result.hasField6 = false; | |
| result.field6_ = 0; | |
| return this; | |
| } | |
| public bool HasField22 { | |
| get { return result.HasField22; } | |
| } | |
| public long Field22 { | |
| get { return result.Field22; } | |
| set { SetField22(value); } | |
| } | |
| public Builder SetField22(long value) { | |
| result.hasField22 = true; | |
| result.field22_ = value; | |
| return this; | |
| } | |
| public Builder ClearField22() { | |
| result.hasField22 = false; | |
| result.field22_ = 0L; | |
| return this; | |
| } | |
| public bool HasField4 { | |
| get { return result.HasField4; } | |
| } | |
| public string Field4 { | |
| get { return result.Field4; } | |
| set { SetField4(value); } | |
| } | |
| public Builder SetField4(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField4 = true; | |
| result.field4_ = value; | |
| return this; | |
| } | |
| public Builder ClearField4() { | |
| result.hasField4 = false; | |
| result.field4_ = ""; | |
| return this; | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public pbc::IPopsicleList<ulong> Field5List { | |
| get { return result.field5_; } | |
| } | |
| public int Field5Count { | |
| get { return result.Field5Count; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong GetField5(int index) { | |
| return result.GetField5(index); | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public Builder SetField5(int index, ulong value) { | |
| result.field5_[index] = value; | |
| return this; | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public Builder AddField5(ulong value) { | |
| result.field5_.Add(value); | |
| return this; | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public Builder AddRangeField5(scg::IEnumerable<ulong> values) { | |
| base.AddRange(values, result.field5_); | |
| return this; | |
| } | |
| public Builder ClearField5() { | |
| result.field5_.Clear(); | |
| return this; | |
| } | |
| public bool HasField59 { | |
| get { return result.HasField59; } | |
| } | |
| public bool Field59 { | |
| get { return result.Field59; } | |
| set { SetField59(value); } | |
| } | |
| public Builder SetField59(bool value) { | |
| result.hasField59 = true; | |
| result.field59_ = value; | |
| return this; | |
| } | |
| public Builder ClearField59() { | |
| result.hasField59 = false; | |
| result.field59_ = false; | |
| return this; | |
| } | |
| public bool HasField7 { | |
| get { return result.HasField7; } | |
| } | |
| public string Field7 { | |
| get { return result.Field7; } | |
| set { SetField7(value); } | |
| } | |
| public Builder SetField7(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField7 = true; | |
| result.field7_ = value; | |
| return this; | |
| } | |
| public Builder ClearField7() { | |
| result.hasField7 = false; | |
| result.field7_ = ""; | |
| return this; | |
| } | |
| public bool HasField16 { | |
| get { return result.HasField16; } | |
| } | |
| public int Field16 { | |
| get { return result.Field16; } | |
| set { SetField16(value); } | |
| } | |
| public Builder SetField16(int value) { | |
| result.hasField16 = true; | |
| result.field16_ = value; | |
| return this; | |
| } | |
| public Builder ClearField16() { | |
| result.hasField16 = false; | |
| result.field16_ = 0; | |
| return this; | |
| } | |
| public bool HasField130 { | |
| get { return result.HasField130; } | |
| } | |
| public int Field130 { | |
| get { return result.Field130; } | |
| set { SetField130(value); } | |
| } | |
| public Builder SetField130(int value) { | |
| result.hasField130 = true; | |
| result.field130_ = value; | |
| return this; | |
| } | |
| public Builder ClearField130() { | |
| result.hasField130 = false; | |
| result.field130_ = 0; | |
| return this; | |
| } | |
| public bool HasField12 { | |
| get { return result.HasField12; } | |
| } | |
| public bool Field12 { | |
| get { return result.Field12; } | |
| set { SetField12(value); } | |
| } | |
| public Builder SetField12(bool value) { | |
| result.hasField12 = true; | |
| result.field12_ = value; | |
| return this; | |
| } | |
| public Builder ClearField12() { | |
| result.hasField12 = false; | |
| result.field12_ = true; | |
| return this; | |
| } | |
| public bool HasField17 { | |
| get { return result.HasField17; } | |
| } | |
| public bool Field17 { | |
| get { return result.Field17; } | |
| set { SetField17(value); } | |
| } | |
| public Builder SetField17(bool value) { | |
| result.hasField17 = true; | |
| result.field17_ = value; | |
| return this; | |
| } | |
| public Builder ClearField17() { | |
| result.hasField17 = false; | |
| result.field17_ = true; | |
| return this; | |
| } | |
| public bool HasField13 { | |
| get { return result.HasField13; } | |
| } | |
| public bool Field13 { | |
| get { return result.Field13; } | |
| set { SetField13(value); } | |
| } | |
| public Builder SetField13(bool value) { | |
| result.hasField13 = true; | |
| result.field13_ = value; | |
| return this; | |
| } | |
| public Builder ClearField13() { | |
| result.hasField13 = false; | |
| result.field13_ = true; | |
| return this; | |
| } | |
| public bool HasField14 { | |
| get { return result.HasField14; } | |
| } | |
| public bool Field14 { | |
| get { return result.Field14; } | |
| set { SetField14(value); } | |
| } | |
| public Builder SetField14(bool value) { | |
| result.hasField14 = true; | |
| result.field14_ = value; | |
| return this; | |
| } | |
| public Builder ClearField14() { | |
| result.hasField14 = false; | |
| result.field14_ = true; | |
| return this; | |
| } | |
| public bool HasField104 { | |
| get { return result.HasField104; } | |
| } | |
| public int Field104 { | |
| get { return result.Field104; } | |
| set { SetField104(value); } | |
| } | |
| public Builder SetField104(int value) { | |
| result.hasField104 = true; | |
| result.field104_ = value; | |
| return this; | |
| } | |
| public Builder ClearField104() { | |
| result.hasField104 = false; | |
| result.field104_ = 0; | |
| return this; | |
| } | |
| public bool HasField100 { | |
| get { return result.HasField100; } | |
| } | |
| public int Field100 { | |
| get { return result.Field100; } | |
| set { SetField100(value); } | |
| } | |
| public Builder SetField100(int value) { | |
| result.hasField100 = true; | |
| result.field100_ = value; | |
| return this; | |
| } | |
| public Builder ClearField100() { | |
| result.hasField100 = false; | |
| result.field100_ = 0; | |
| return this; | |
| } | |
| public bool HasField101 { | |
| get { return result.HasField101; } | |
| } | |
| public int Field101 { | |
| get { return result.Field101; } | |
| set { SetField101(value); } | |
| } | |
| public Builder SetField101(int value) { | |
| result.hasField101 = true; | |
| result.field101_ = value; | |
| return this; | |
| } | |
| public Builder ClearField101() { | |
| result.hasField101 = false; | |
| result.field101_ = 0; | |
| return this; | |
| } | |
| public bool HasField102 { | |
| get { return result.HasField102; } | |
| } | |
| public string Field102 { | |
| get { return result.Field102; } | |
| set { SetField102(value); } | |
| } | |
| public Builder SetField102(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField102 = true; | |
| result.field102_ = value; | |
| return this; | |
| } | |
| public Builder ClearField102() { | |
| result.hasField102 = false; | |
| result.field102_ = ""; | |
| return this; | |
| } | |
| public bool HasField103 { | |
| get { return result.HasField103; } | |
| } | |
| public string Field103 { | |
| get { return result.Field103; } | |
| set { SetField103(value); } | |
| } | |
| public Builder SetField103(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField103 = true; | |
| result.field103_ = value; | |
| return this; | |
| } | |
| public Builder ClearField103() { | |
| result.hasField103 = false; | |
| result.field103_ = ""; | |
| return this; | |
| } | |
| public bool HasField29 { | |
| get { return result.HasField29; } | |
| } | |
| public int Field29 { | |
| get { return result.Field29; } | |
| set { SetField29(value); } | |
| } | |
| public Builder SetField29(int value) { | |
| result.hasField29 = true; | |
| result.field29_ = value; | |
| return this; | |
| } | |
| public Builder ClearField29() { | |
| result.hasField29 = false; | |
| result.field29_ = 0; | |
| return this; | |
| } | |
| public bool HasField30 { | |
| get { return result.HasField30; } | |
| } | |
| public bool Field30 { | |
| get { return result.Field30; } | |
| set { SetField30(value); } | |
| } | |
| public Builder SetField30(bool value) { | |
| result.hasField30 = true; | |
| result.field30_ = value; | |
| return this; | |
| } | |
| public Builder ClearField30() { | |
| result.hasField30 = false; | |
| result.field30_ = false; | |
| return this; | |
| } | |
| public bool HasField60 { | |
| get { return result.HasField60; } | |
| } | |
| public int Field60 { | |
| get { return result.Field60; } | |
| set { SetField60(value); } | |
| } | |
| public Builder SetField60(int value) { | |
| result.hasField60 = true; | |
| result.field60_ = value; | |
| return this; | |
| } | |
| public Builder ClearField60() { | |
| result.hasField60 = false; | |
| result.field60_ = -1; | |
| return this; | |
| } | |
| public bool HasField271 { | |
| get { return result.HasField271; } | |
| } | |
| public int Field271 { | |
| get { return result.Field271; } | |
| set { SetField271(value); } | |
| } | |
| public Builder SetField271(int value) { | |
| result.hasField271 = true; | |
| result.field271_ = value; | |
| return this; | |
| } | |
| public Builder ClearField271() { | |
| result.hasField271 = false; | |
| result.field271_ = -1; | |
| return this; | |
| } | |
| public bool HasField272 { | |
| get { return result.HasField272; } | |
| } | |
| public int Field272 { | |
| get { return result.Field272; } | |
| set { SetField272(value); } | |
| } | |
| public Builder SetField272(int value) { | |
| result.hasField272 = true; | |
| result.field272_ = value; | |
| return this; | |
| } | |
| public Builder ClearField272() { | |
| result.hasField272 = false; | |
| result.field272_ = -1; | |
| return this; | |
| } | |
| public bool HasField150 { | |
| get { return result.HasField150; } | |
| } | |
| public int Field150 { | |
| get { return result.Field150; } | |
| set { SetField150(value); } | |
| } | |
| public Builder SetField150(int value) { | |
| result.hasField150 = true; | |
| result.field150_ = value; | |
| return this; | |
| } | |
| public Builder ClearField150() { | |
| result.hasField150 = false; | |
| result.field150_ = 0; | |
| return this; | |
| } | |
| public bool HasField23 { | |
| get { return result.HasField23; } | |
| } | |
| public int Field23 { | |
| get { return result.Field23; } | |
| set { SetField23(value); } | |
| } | |
| public Builder SetField23(int value) { | |
| result.hasField23 = true; | |
| result.field23_ = value; | |
| return this; | |
| } | |
| public Builder ClearField23() { | |
| result.hasField23 = false; | |
| result.field23_ = 0; | |
| return this; | |
| } | |
| public bool HasField24 { | |
| get { return result.HasField24; } | |
| } | |
| public bool Field24 { | |
| get { return result.Field24; } | |
| set { SetField24(value); } | |
| } | |
| public Builder SetField24(bool value) { | |
| result.hasField24 = true; | |
| result.field24_ = value; | |
| return this; | |
| } | |
| public Builder ClearField24() { | |
| result.hasField24 = false; | |
| result.field24_ = false; | |
| return this; | |
| } | |
| public bool HasField25 { | |
| get { return result.HasField25; } | |
| } | |
| public int Field25 { | |
| get { return result.Field25; } | |
| set { SetField25(value); } | |
| } | |
| public Builder SetField25(int value) { | |
| result.hasField25 = true; | |
| result.field25_ = value; | |
| return this; | |
| } | |
| public Builder ClearField25() { | |
| result.hasField25 = false; | |
| result.field25_ = 0; | |
| return this; | |
| } | |
| public bool HasField15 { | |
| get { return result.HasField15; } | |
| } | |
| public global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage Field15 { | |
| get { return result.Field15; } | |
| set { SetField15(value); } | |
| } | |
| public Builder SetField15(global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField15 = true; | |
| result.field15_ = value; | |
| return this; | |
| } | |
| public Builder SetField15(global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder builderForValue) { | |
| pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | |
| result.hasField15 = true; | |
| result.field15_ = builderForValue.Build(); | |
| return this; | |
| } | |
| public Builder MergeField15(global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| if (result.HasField15 && | |
| result.field15_ != global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance) { | |
| result.field15_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.CreateBuilder(result.field15_).MergeFrom(value).BuildPartial(); | |
| } else { | |
| result.field15_ = value; | |
| } | |
| result.hasField15 = true; | |
| return this; | |
| } | |
| public Builder ClearField15() { | |
| result.hasField15 = false; | |
| result.field15_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance; | |
| return this; | |
| } | |
| public bool HasField78 { | |
| get { return result.HasField78; } | |
| } | |
| public bool Field78 { | |
| get { return result.Field78; } | |
| set { SetField78(value); } | |
| } | |
| public Builder SetField78(bool value) { | |
| result.hasField78 = true; | |
| result.field78_ = value; | |
| return this; | |
| } | |
| public Builder ClearField78() { | |
| result.hasField78 = false; | |
| result.field78_ = false; | |
| return this; | |
| } | |
| public bool HasField67 { | |
| get { return result.HasField67; } | |
| } | |
| public int Field67 { | |
| get { return result.Field67; } | |
| set { SetField67(value); } | |
| } | |
| public Builder SetField67(int value) { | |
| result.hasField67 = true; | |
| result.field67_ = value; | |
| return this; | |
| } | |
| public Builder ClearField67() { | |
| result.hasField67 = false; | |
| result.field67_ = 0; | |
| return this; | |
| } | |
| public bool HasField68 { | |
| get { return result.HasField68; } | |
| } | |
| public int Field68 { | |
| get { return result.Field68; } | |
| set { SetField68(value); } | |
| } | |
| public Builder SetField68(int value) { | |
| result.hasField68 = true; | |
| result.field68_ = value; | |
| return this; | |
| } | |
| public Builder ClearField68() { | |
| result.hasField68 = false; | |
| result.field68_ = 0; | |
| return this; | |
| } | |
| public bool HasField128 { | |
| get { return result.HasField128; } | |
| } | |
| public int Field128 { | |
| get { return result.Field128; } | |
| set { SetField128(value); } | |
| } | |
| public Builder SetField128(int value) { | |
| result.hasField128 = true; | |
| result.field128_ = value; | |
| return this; | |
| } | |
| public Builder ClearField128() { | |
| result.hasField128 = false; | |
| result.field128_ = 0; | |
| return this; | |
| } | |
| public bool HasField129 { | |
| get { return result.HasField129; } | |
| } | |
| public string Field129 { | |
| get { return result.Field129; } | |
| set { SetField129(value); } | |
| } | |
| public Builder SetField129(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField129 = true; | |
| result.field129_ = value; | |
| return this; | |
| } | |
| public Builder ClearField129() { | |
| result.hasField129 = false; | |
| result.field129_ = "xxxxxxxxxxxxxxxxxxxxx"; | |
| return this; | |
| } | |
| public bool HasField131 { | |
| get { return result.HasField131; } | |
| } | |
| public int Field131 { | |
| get { return result.Field131; } | |
| set { SetField131(value); } | |
| } | |
| public Builder SetField131(int value) { | |
| result.hasField131 = true; | |
| result.field131_ = value; | |
| return this; | |
| } | |
| public Builder ClearField131() { | |
| result.hasField131 = false; | |
| result.field131_ = 0; | |
| return this; | |
| } | |
| } | |
| static SpeedMessage1() { | |
| object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null); | |
| } | |
| } | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class SpeedMessage1SubMessage : pb::GeneratedMessage<SpeedMessage1SubMessage, SpeedMessage1SubMessage.Builder> { | |
| private static readonly SpeedMessage1SubMessage defaultInstance = new Builder().BuildPartial(); | |
| public static SpeedMessage1SubMessage DefaultInstance { | |
| get { return defaultInstance; } | |
| } | |
| public override SpeedMessage1SubMessage DefaultInstanceForType { | |
| get { return defaultInstance; } | |
| } | |
| protected override SpeedMessage1SubMessage ThisMessage { | |
| get { return this; } | |
| } | |
| public static pbd::MessageDescriptor Descriptor { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage1SubMessage__Descriptor; } | |
| } | |
| protected override pb::FieldAccess.FieldAccessorTable<SpeedMessage1SubMessage, SpeedMessage1SubMessage.Builder> InternalFieldAccessors { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage1SubMessage__FieldAccessorTable; } | |
| } | |
| public const int Field1FieldNumber = 1; | |
| private bool hasField1; | |
| private int field1_ = 0; | |
| public bool HasField1 { | |
| get { return hasField1; } | |
| } | |
| public int Field1 { | |
| get { return field1_; } | |
| } | |
| public const int Field2FieldNumber = 2; | |
| private bool hasField2; | |
| private int field2_ = 0; | |
| public bool HasField2 { | |
| get { return hasField2; } | |
| } | |
| public int Field2 { | |
| get { return field2_; } | |
| } | |
| public const int Field3FieldNumber = 3; | |
| private bool hasField3; | |
| private int field3_ = 0; | |
| public bool HasField3 { | |
| get { return hasField3; } | |
| } | |
| public int Field3 { | |
| get { return field3_; } | |
| } | |
| public const int Field15FieldNumber = 15; | |
| private bool hasField15; | |
| private string field15_ = ""; | |
| public bool HasField15 { | |
| get { return hasField15; } | |
| } | |
| public string Field15 { | |
| get { return field15_; } | |
| } | |
| public const int Field12FieldNumber = 12; | |
| private bool hasField12; | |
| private bool field12_ = true; | |
| public bool HasField12 { | |
| get { return hasField12; } | |
| } | |
| public bool Field12 { | |
| get { return field12_; } | |
| } | |
| public const int Field13FieldNumber = 13; | |
| private bool hasField13; | |
| private long field13_ = 0L; | |
| public bool HasField13 { | |
| get { return hasField13; } | |
| } | |
| public long Field13 { | |
| get { return field13_; } | |
| } | |
| public const int Field14FieldNumber = 14; | |
| private bool hasField14; | |
| private long field14_ = 0L; | |
| public bool HasField14 { | |
| get { return hasField14; } | |
| } | |
| public long Field14 { | |
| get { return field14_; } | |
| } | |
| public const int Field16FieldNumber = 16; | |
| private bool hasField16; | |
| private int field16_ = 0; | |
| public bool HasField16 { | |
| get { return hasField16; } | |
| } | |
| public int Field16 { | |
| get { return field16_; } | |
| } | |
| public const int Field19FieldNumber = 19; | |
| private bool hasField19; | |
| private int field19_ = 2; | |
| public bool HasField19 { | |
| get { return hasField19; } | |
| } | |
| public int Field19 { | |
| get { return field19_; } | |
| } | |
| public const int Field20FieldNumber = 20; | |
| private bool hasField20; | |
| private bool field20_ = true; | |
| public bool HasField20 { | |
| get { return hasField20; } | |
| } | |
| public bool Field20 { | |
| get { return field20_; } | |
| } | |
| public const int Field28FieldNumber = 28; | |
| private bool hasField28; | |
| private bool field28_ = true; | |
| public bool HasField28 { | |
| get { return hasField28; } | |
| } | |
| public bool Field28 { | |
| get { return field28_; } | |
| } | |
| public const int Field21FieldNumber = 21; | |
| private bool hasField21; | |
| private ulong field21_ = 0; | |
| public bool HasField21 { | |
| get { return hasField21; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong Field21 { | |
| get { return field21_; } | |
| } | |
| public const int Field22FieldNumber = 22; | |
| private bool hasField22; | |
| private int field22_ = 0; | |
| public bool HasField22 { | |
| get { return hasField22; } | |
| } | |
| public int Field22 { | |
| get { return field22_; } | |
| } | |
| public const int Field23FieldNumber = 23; | |
| private bool hasField23; | |
| private bool field23_ = false; | |
| public bool HasField23 { | |
| get { return hasField23; } | |
| } | |
| public bool Field23 { | |
| get { return field23_; } | |
| } | |
| public const int Field206FieldNumber = 206; | |
| private bool hasField206; | |
| private bool field206_ = false; | |
| public bool HasField206 { | |
| get { return hasField206; } | |
| } | |
| public bool Field206 { | |
| get { return field206_; } | |
| } | |
| public const int Field203FieldNumber = 203; | |
| private bool hasField203; | |
| private uint field203_ = 0; | |
| public bool HasField203 { | |
| get { return hasField203; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public uint Field203 { | |
| get { return field203_; } | |
| } | |
| public const int Field204FieldNumber = 204; | |
| private bool hasField204; | |
| private int field204_ = 0; | |
| public bool HasField204 { | |
| get { return hasField204; } | |
| } | |
| public int Field204 { | |
| get { return field204_; } | |
| } | |
| public const int Field205FieldNumber = 205; | |
| private bool hasField205; | |
| private string field205_ = ""; | |
| public bool HasField205 { | |
| get { return hasField205; } | |
| } | |
| public string Field205 { | |
| get { return field205_; } | |
| } | |
| public const int Field207FieldNumber = 207; | |
| private bool hasField207; | |
| private ulong field207_ = 0UL; | |
| public bool HasField207 { | |
| get { return hasField207; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong Field207 { | |
| get { return field207_; } | |
| } | |
| public const int Field300FieldNumber = 300; | |
| private bool hasField300; | |
| private ulong field300_ = 0UL; | |
| public bool HasField300 { | |
| get { return hasField300; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong Field300 { | |
| get { return field300_; } | |
| } | |
| public override bool IsInitialized { | |
| get { | |
| return true; | |
| } | |
| } | |
| public override void WriteTo(pb::CodedOutputStream output) { | |
| int size = SerializedSize; | |
| if (HasField1) { | |
| output.WriteInt32(1, "field1", Field1); | |
| } | |
| if (HasField2) { | |
| output.WriteInt32(2, "field2", Field2); | |
| } | |
| if (HasField3) { | |
| output.WriteInt32(3, "field3", Field3); | |
| } | |
| if (HasField12) { | |
| output.WriteBool(12, "field12", Field12); | |
| } | |
| if (HasField13) { | |
| output.WriteInt64(13, "field13", Field13); | |
| } | |
| if (HasField14) { | |
| output.WriteInt64(14, "field14", Field14); | |
| } | |
| if (HasField15) { | |
| output.WriteString(15, "field15", Field15); | |
| } | |
| if (HasField16) { | |
| output.WriteInt32(16, "field16", Field16); | |
| } | |
| if (HasField19) { | |
| output.WriteInt32(19, "field19", Field19); | |
| } | |
| if (HasField20) { | |
| output.WriteBool(20, "field20", Field20); | |
| } | |
| if (HasField21) { | |
| output.WriteFixed64(21, "field21", Field21); | |
| } | |
| if (HasField22) { | |
| output.WriteInt32(22, "field22", Field22); | |
| } | |
| if (HasField23) { | |
| output.WriteBool(23, "field23", Field23); | |
| } | |
| if (HasField28) { | |
| output.WriteBool(28, "field28", Field28); | |
| } | |
| if (HasField203) { | |
| output.WriteFixed32(203, "field203", Field203); | |
| } | |
| if (HasField204) { | |
| output.WriteInt32(204, "field204", Field204); | |
| } | |
| if (HasField205) { | |
| output.WriteString(205, "field205", Field205); | |
| } | |
| if (HasField206) { | |
| output.WriteBool(206, "field206", Field206); | |
| } | |
| if (HasField207) { | |
| output.WriteUInt64(207, "field207", Field207); | |
| } | |
| if (HasField300) { | |
| output.WriteUInt64(300, "field300", Field300); | |
| } | |
| UnknownFields.WriteTo(output); | |
| } | |
| private int memoizedSerializedSize = -1; | |
| public override int SerializedSize { | |
| get { | |
| int size = memoizedSerializedSize; | |
| if (size != -1) return size; | |
| size = 0; | |
| if (HasField1) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(1, Field1); | |
| } | |
| if (HasField2) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(2, Field2); | |
| } | |
| if (HasField3) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(3, Field3); | |
| } | |
| if (HasField15) { | |
| size += pb::CodedOutputStream.ComputeStringSize(15, Field15); | |
| } | |
| if (HasField12) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(12, Field12); | |
| } | |
| if (HasField13) { | |
| size += pb::CodedOutputStream.ComputeInt64Size(13, Field13); | |
| } | |
| if (HasField14) { | |
| size += pb::CodedOutputStream.ComputeInt64Size(14, Field14); | |
| } | |
| if (HasField16) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(16, Field16); | |
| } | |
| if (HasField19) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(19, Field19); | |
| } | |
| if (HasField20) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(20, Field20); | |
| } | |
| if (HasField28) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(28, Field28); | |
| } | |
| if (HasField21) { | |
| size += pb::CodedOutputStream.ComputeFixed64Size(21, Field21); | |
| } | |
| if (HasField22) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(22, Field22); | |
| } | |
| if (HasField23) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(23, Field23); | |
| } | |
| if (HasField206) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(206, Field206); | |
| } | |
| if (HasField203) { | |
| size += pb::CodedOutputStream.ComputeFixed32Size(203, Field203); | |
| } | |
| if (HasField204) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(204, Field204); | |
| } | |
| if (HasField205) { | |
| size += pb::CodedOutputStream.ComputeStringSize(205, Field205); | |
| } | |
| if (HasField207) { | |
| size += pb::CodedOutputStream.ComputeUInt64Size(207, Field207); | |
| } | |
| if (HasField300) { | |
| size += pb::CodedOutputStream.ComputeUInt64Size(300, Field300); | |
| } | |
| size += UnknownFields.SerializedSize; | |
| memoizedSerializedSize = size; | |
| return size; | |
| } | |
| } | |
| public static SpeedMessage1SubMessage ParseFrom(pb::ByteString data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static SpeedMessage1SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage1SubMessage ParseFrom(byte[] data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static SpeedMessage1SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage1SubMessage ParseFrom(global::System.IO.Stream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static SpeedMessage1SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage1SubMessage ParseDelimitedFrom(global::System.IO.Stream input) { | |
| return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | |
| } | |
| public static SpeedMessage1SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | |
| } | |
| public static SpeedMessage1SubMessage ParseFrom(pb::CodedInputStream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static SpeedMessage1SubMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static Builder CreateBuilder() { return new Builder(); } | |
| public override Builder ToBuilder() { return CreateBuilder(this); } | |
| public override Builder CreateBuilderForType() { return new Builder(); } | |
| public static Builder CreateBuilder(SpeedMessage1SubMessage prototype) { | |
| return (Builder) new Builder().MergeFrom(prototype); | |
| } | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class Builder : pb::GeneratedBuilder<SpeedMessage1SubMessage, Builder> { | |
| protected override Builder ThisBuilder { | |
| get { return this; } | |
| } | |
| public Builder() {} | |
| SpeedMessage1SubMessage result = new SpeedMessage1SubMessage(); | |
| protected override SpeedMessage1SubMessage MessageBeingBuilt { | |
| get { return result; } | |
| } | |
| public override Builder Clear() { | |
| result = new SpeedMessage1SubMessage(); | |
| return this; | |
| } | |
| public override Builder Clone() { | |
| return new Builder().MergeFrom(result); | |
| } | |
| public override pbd::MessageDescriptor DescriptorForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Descriptor; } | |
| } | |
| public override SpeedMessage1SubMessage DefaultInstanceForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance; } | |
| } | |
| public override SpeedMessage1SubMessage BuildPartial() { | |
| if (result == null) { | |
| throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | |
| } | |
| SpeedMessage1SubMessage returnMe = result; | |
| result = null; | |
| return returnMe; | |
| } | |
| public override Builder MergeFrom(pb::IMessage other) { | |
| if (other is SpeedMessage1SubMessage) { | |
| return MergeFrom((SpeedMessage1SubMessage) other); | |
| } else { | |
| base.MergeFrom(other); | |
| return this; | |
| } | |
| } | |
| public override Builder MergeFrom(SpeedMessage1SubMessage other) { | |
| if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance) return this; | |
| if (other.HasField1) { | |
| Field1 = other.Field1; | |
| } | |
| if (other.HasField2) { | |
| Field2 = other.Field2; | |
| } | |
| if (other.HasField3) { | |
| Field3 = other.Field3; | |
| } | |
| if (other.HasField15) { | |
| Field15 = other.Field15; | |
| } | |
| if (other.HasField12) { | |
| Field12 = other.Field12; | |
| } | |
| if (other.HasField13) { | |
| Field13 = other.Field13; | |
| } | |
| if (other.HasField14) { | |
| Field14 = other.Field14; | |
| } | |
| if (other.HasField16) { | |
| Field16 = other.Field16; | |
| } | |
| if (other.HasField19) { | |
| Field19 = other.Field19; | |
| } | |
| if (other.HasField20) { | |
| Field20 = other.Field20; | |
| } | |
| if (other.HasField28) { | |
| Field28 = other.Field28; | |
| } | |
| if (other.HasField21) { | |
| Field21 = other.Field21; | |
| } | |
| if (other.HasField22) { | |
| Field22 = other.Field22; | |
| } | |
| if (other.HasField23) { | |
| Field23 = other.Field23; | |
| } | |
| if (other.HasField206) { | |
| Field206 = other.Field206; | |
| } | |
| if (other.HasField203) { | |
| Field203 = other.Field203; | |
| } | |
| if (other.HasField204) { | |
| Field204 = other.Field204; | |
| } | |
| if (other.HasField205) { | |
| Field205 = other.Field205; | |
| } | |
| if (other.HasField207) { | |
| Field207 = other.Field207; | |
| } | |
| if (other.HasField300) { | |
| Field300 = other.Field300; | |
| } | |
| this.MergeUnknownFields(other.UnknownFields); | |
| return this; | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input) { | |
| return MergeFrom(input, pb::ExtensionRegistry.Empty); | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| pb::UnknownFieldSet.Builder unknownFields = null; | |
| while (true) { | |
| uint tag = input.ReadTag(); | |
| switch (tag) { | |
| case 0: { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| default: { | |
| if (pb::WireFormat.IsEndGroupTag(tag)) { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| if (unknownFields == null) { | |
| unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | |
| } | |
| ParseUnknownField(input, unknownFields, extensionRegistry, tag); | |
| break; | |
| } | |
| case 8: { | |
| Field1 = input.ReadInt32(); | |
| break; | |
| } | |
| case 16: { | |
| Field2 = input.ReadInt32(); | |
| break; | |
| } | |
| case 24: { | |
| Field3 = input.ReadInt32(); | |
| break; | |
| } | |
| case 96: { | |
| Field12 = input.ReadBool(); | |
| break; | |
| } | |
| case 104: { | |
| Field13 = input.ReadInt64(); | |
| break; | |
| } | |
| case 112: { | |
| Field14 = input.ReadInt64(); | |
| break; | |
| } | |
| case 122: { | |
| Field15 = input.ReadString(); | |
| break; | |
| } | |
| case 128: { | |
| Field16 = input.ReadInt32(); | |
| break; | |
| } | |
| case 152: { | |
| Field19 = input.ReadInt32(); | |
| break; | |
| } | |
| case 160: { | |
| Field20 = input.ReadBool(); | |
| break; | |
| } | |
| case 169: { | |
| Field21 = input.ReadFixed64(); | |
| break; | |
| } | |
| case 176: { | |
| Field22 = input.ReadInt32(); | |
| break; | |
| } | |
| case 184: { | |
| Field23 = input.ReadBool(); | |
| break; | |
| } | |
| case 224: { | |
| Field28 = input.ReadBool(); | |
| break; | |
| } | |
| case 1629: { | |
| Field203 = input.ReadFixed32(); | |
| break; | |
| } | |
| case 1632: { | |
| Field204 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1642: { | |
| Field205 = input.ReadString(); | |
| break; | |
| } | |
| case 1648: { | |
| Field206 = input.ReadBool(); | |
| break; | |
| } | |
| case 1656: { | |
| Field207 = input.ReadUInt64(); | |
| break; | |
| } | |
| case 2400: { | |
| Field300 = input.ReadUInt64(); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| public bool HasField1 { | |
| get { return result.HasField1; } | |
| } | |
| public int Field1 { | |
| get { return result.Field1; } | |
| set { SetField1(value); } | |
| } | |
| public Builder SetField1(int value) { | |
| result.hasField1 = true; | |
| result.field1_ = value; | |
| return this; | |
| } | |
| public Builder ClearField1() { | |
| result.hasField1 = false; | |
| result.field1_ = 0; | |
| return this; | |
| } | |
| public bool HasField2 { | |
| get { return result.HasField2; } | |
| } | |
| public int Field2 { | |
| get { return result.Field2; } | |
| set { SetField2(value); } | |
| } | |
| public Builder SetField2(int value) { | |
| result.hasField2 = true; | |
| result.field2_ = value; | |
| return this; | |
| } | |
| public Builder ClearField2() { | |
| result.hasField2 = false; | |
| result.field2_ = 0; | |
| return this; | |
| } | |
| public bool HasField3 { | |
| get { return result.HasField3; } | |
| } | |
| public int Field3 { | |
| get { return result.Field3; } | |
| set { SetField3(value); } | |
| } | |
| public Builder SetField3(int value) { | |
| result.hasField3 = true; | |
| result.field3_ = value; | |
| return this; | |
| } | |
| public Builder ClearField3() { | |
| result.hasField3 = false; | |
| result.field3_ = 0; | |
| return this; | |
| } | |
| public bool HasField15 { | |
| get { return result.HasField15; } | |
| } | |
| public string Field15 { | |
| get { return result.Field15; } | |
| set { SetField15(value); } | |
| } | |
| public Builder SetField15(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField15 = true; | |
| result.field15_ = value; | |
| return this; | |
| } | |
| public Builder ClearField15() { | |
| result.hasField15 = false; | |
| result.field15_ = ""; | |
| return this; | |
| } | |
| public bool HasField12 { | |
| get { return result.HasField12; } | |
| } | |
| public bool Field12 { | |
| get { return result.Field12; } | |
| set { SetField12(value); } | |
| } | |
| public Builder SetField12(bool value) { | |
| result.hasField12 = true; | |
| result.field12_ = value; | |
| return this; | |
| } | |
| public Builder ClearField12() { | |
| result.hasField12 = false; | |
| result.field12_ = true; | |
| return this; | |
| } | |
| public bool HasField13 { | |
| get { return result.HasField13; } | |
| } | |
| public long Field13 { | |
| get { return result.Field13; } | |
| set { SetField13(value); } | |
| } | |
| public Builder SetField13(long value) { | |
| result.hasField13 = true; | |
| result.field13_ = value; | |
| return this; | |
| } | |
| public Builder ClearField13() { | |
| result.hasField13 = false; | |
| result.field13_ = 0L; | |
| return this; | |
| } | |
| public bool HasField14 { | |
| get { return result.HasField14; } | |
| } | |
| public long Field14 { | |
| get { return result.Field14; } | |
| set { SetField14(value); } | |
| } | |
| public Builder SetField14(long value) { | |
| result.hasField14 = true; | |
| result.field14_ = value; | |
| return this; | |
| } | |
| public Builder ClearField14() { | |
| result.hasField14 = false; | |
| result.field14_ = 0L; | |
| return this; | |
| } | |
| public bool HasField16 { | |
| get { return result.HasField16; } | |
| } | |
| public int Field16 { | |
| get { return result.Field16; } | |
| set { SetField16(value); } | |
| } | |
| public Builder SetField16(int value) { | |
| result.hasField16 = true; | |
| result.field16_ = value; | |
| return this; | |
| } | |
| public Builder ClearField16() { | |
| result.hasField16 = false; | |
| result.field16_ = 0; | |
| return this; | |
| } | |
| public bool HasField19 { | |
| get { return result.HasField19; } | |
| } | |
| public int Field19 { | |
| get { return result.Field19; } | |
| set { SetField19(value); } | |
| } | |
| public Builder SetField19(int value) { | |
| result.hasField19 = true; | |
| result.field19_ = value; | |
| return this; | |
| } | |
| public Builder ClearField19() { | |
| result.hasField19 = false; | |
| result.field19_ = 2; | |
| return this; | |
| } | |
| public bool HasField20 { | |
| get { return result.HasField20; } | |
| } | |
| public bool Field20 { | |
| get { return result.Field20; } | |
| set { SetField20(value); } | |
| } | |
| public Builder SetField20(bool value) { | |
| result.hasField20 = true; | |
| result.field20_ = value; | |
| return this; | |
| } | |
| public Builder ClearField20() { | |
| result.hasField20 = false; | |
| result.field20_ = true; | |
| return this; | |
| } | |
| public bool HasField28 { | |
| get { return result.HasField28; } | |
| } | |
| public bool Field28 { | |
| get { return result.Field28; } | |
| set { SetField28(value); } | |
| } | |
| public Builder SetField28(bool value) { | |
| result.hasField28 = true; | |
| result.field28_ = value; | |
| return this; | |
| } | |
| public Builder ClearField28() { | |
| result.hasField28 = false; | |
| result.field28_ = true; | |
| return this; | |
| } | |
| public bool HasField21 { | |
| get { return result.HasField21; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong Field21 { | |
| get { return result.Field21; } | |
| set { SetField21(value); } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public Builder SetField21(ulong value) { | |
| result.hasField21 = true; | |
| result.field21_ = value; | |
| return this; | |
| } | |
| public Builder ClearField21() { | |
| result.hasField21 = false; | |
| result.field21_ = 0; | |
| return this; | |
| } | |
| public bool HasField22 { | |
| get { return result.HasField22; } | |
| } | |
| public int Field22 { | |
| get { return result.Field22; } | |
| set { SetField22(value); } | |
| } | |
| public Builder SetField22(int value) { | |
| result.hasField22 = true; | |
| result.field22_ = value; | |
| return this; | |
| } | |
| public Builder ClearField22() { | |
| result.hasField22 = false; | |
| result.field22_ = 0; | |
| return this; | |
| } | |
| public bool HasField23 { | |
| get { return result.HasField23; } | |
| } | |
| public bool Field23 { | |
| get { return result.Field23; } | |
| set { SetField23(value); } | |
| } | |
| public Builder SetField23(bool value) { | |
| result.hasField23 = true; | |
| result.field23_ = value; | |
| return this; | |
| } | |
| public Builder ClearField23() { | |
| result.hasField23 = false; | |
| result.field23_ = false; | |
| return this; | |
| } | |
| public bool HasField206 { | |
| get { return result.HasField206; } | |
| } | |
| public bool Field206 { | |
| get { return result.Field206; } | |
| set { SetField206(value); } | |
| } | |
| public Builder SetField206(bool value) { | |
| result.hasField206 = true; | |
| result.field206_ = value; | |
| return this; | |
| } | |
| public Builder ClearField206() { | |
| result.hasField206 = false; | |
| result.field206_ = false; | |
| return this; | |
| } | |
| public bool HasField203 { | |
| get { return result.HasField203; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public uint Field203 { | |
| get { return result.Field203; } | |
| set { SetField203(value); } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public Builder SetField203(uint value) { | |
| result.hasField203 = true; | |
| result.field203_ = value; | |
| return this; | |
| } | |
| public Builder ClearField203() { | |
| result.hasField203 = false; | |
| result.field203_ = 0; | |
| return this; | |
| } | |
| public bool HasField204 { | |
| get { return result.HasField204; } | |
| } | |
| public int Field204 { | |
| get { return result.Field204; } | |
| set { SetField204(value); } | |
| } | |
| public Builder SetField204(int value) { | |
| result.hasField204 = true; | |
| result.field204_ = value; | |
| return this; | |
| } | |
| public Builder ClearField204() { | |
| result.hasField204 = false; | |
| result.field204_ = 0; | |
| return this; | |
| } | |
| public bool HasField205 { | |
| get { return result.HasField205; } | |
| } | |
| public string Field205 { | |
| get { return result.Field205; } | |
| set { SetField205(value); } | |
| } | |
| public Builder SetField205(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField205 = true; | |
| result.field205_ = value; | |
| return this; | |
| } | |
| public Builder ClearField205() { | |
| result.hasField205 = false; | |
| result.field205_ = ""; | |
| return this; | |
| } | |
| public bool HasField207 { | |
| get { return result.HasField207; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong Field207 { | |
| get { return result.Field207; } | |
| set { SetField207(value); } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public Builder SetField207(ulong value) { | |
| result.hasField207 = true; | |
| result.field207_ = value; | |
| return this; | |
| } | |
| public Builder ClearField207() { | |
| result.hasField207 = false; | |
| result.field207_ = 0UL; | |
| return this; | |
| } | |
| public bool HasField300 { | |
| get { return result.HasField300; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong Field300 { | |
| get { return result.Field300; } | |
| set { SetField300(value); } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public Builder SetField300(ulong value) { | |
| result.hasField300 = true; | |
| result.field300_ = value; | |
| return this; | |
| } | |
| public Builder ClearField300() { | |
| result.hasField300 = false; | |
| result.field300_ = 0UL; | |
| return this; | |
| } | |
| } | |
| static SpeedMessage1SubMessage() { | |
| object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null); | |
| } | |
| } | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class SpeedMessage2 : pb::GeneratedMessage<SpeedMessage2, SpeedMessage2.Builder> { | |
| private static readonly SpeedMessage2 defaultInstance = new Builder().BuildPartial(); | |
| public static SpeedMessage2 DefaultInstance { | |
| get { return defaultInstance; } | |
| } | |
| public override SpeedMessage2 DefaultInstanceForType { | |
| get { return defaultInstance; } | |
| } | |
| protected override SpeedMessage2 ThisMessage { | |
| get { return this; } | |
| } | |
| public static pbd::MessageDescriptor Descriptor { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage2__Descriptor; } | |
| } | |
| protected override pb::FieldAccess.FieldAccessorTable<SpeedMessage2, SpeedMessage2.Builder> InternalFieldAccessors { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage2__FieldAccessorTable; } | |
| } | |
| #region Nested types | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public static class Types { | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class Group1 : pb::GeneratedMessage<Group1, Group1.Builder> { | |
| private static readonly Group1 defaultInstance = new Builder().BuildPartial(); | |
| public static Group1 DefaultInstance { | |
| get { return defaultInstance; } | |
| } | |
| public override Group1 DefaultInstanceForType { | |
| get { return defaultInstance; } | |
| } | |
| protected override Group1 ThisMessage { | |
| get { return this; } | |
| } | |
| public static pbd::MessageDescriptor Descriptor { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage2_Group1__Descriptor; } | |
| } | |
| protected override pb::FieldAccess.FieldAccessorTable<Group1, Group1.Builder> InternalFieldAccessors { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage2_Group1__FieldAccessorTable; } | |
| } | |
| public const int Field11FieldNumber = 11; | |
| private bool hasField11; | |
| private float field11_ = 0F; | |
| public bool HasField11 { | |
| get { return hasField11; } | |
| } | |
| public float Field11 { | |
| get { return field11_; } | |
| } | |
| public const int Field26FieldNumber = 26; | |
| private bool hasField26; | |
| private float field26_ = 0F; | |
| public bool HasField26 { | |
| get { return hasField26; } | |
| } | |
| public float Field26 { | |
| get { return field26_; } | |
| } | |
| public const int Field12FieldNumber = 12; | |
| private bool hasField12; | |
| private string field12_ = ""; | |
| public bool HasField12 { | |
| get { return hasField12; } | |
| } | |
| public string Field12 { | |
| get { return field12_; } | |
| } | |
| public const int Field13FieldNumber = 13; | |
| private bool hasField13; | |
| private string field13_ = ""; | |
| public bool HasField13 { | |
| get { return hasField13; } | |
| } | |
| public string Field13 { | |
| get { return field13_; } | |
| } | |
| public const int Field14FieldNumber = 14; | |
| private pbc::PopsicleList<string> field14_ = new pbc::PopsicleList<string>(); | |
| public scg::IList<string> Field14List { | |
| get { return pbc::Lists.AsReadOnly(field14_); } | |
| } | |
| public int Field14Count { | |
| get { return field14_.Count; } | |
| } | |
| public string GetField14(int index) { | |
| return field14_[index]; | |
| } | |
| public const int Field15FieldNumber = 15; | |
| private bool hasField15; | |
| private ulong field15_ = 0UL; | |
| public bool HasField15 { | |
| get { return hasField15; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong Field15 { | |
| get { return field15_; } | |
| } | |
| public const int Field5FieldNumber = 5; | |
| private bool hasField5; | |
| private int field5_ = 0; | |
| public bool HasField5 { | |
| get { return hasField5; } | |
| } | |
| public int Field5 { | |
| get { return field5_; } | |
| } | |
| public const int Field27FieldNumber = 27; | |
| private bool hasField27; | |
| private string field27_ = ""; | |
| public bool HasField27 { | |
| get { return hasField27; } | |
| } | |
| public string Field27 { | |
| get { return field27_; } | |
| } | |
| public const int Field28FieldNumber = 28; | |
| private bool hasField28; | |
| private int field28_ = 0; | |
| public bool HasField28 { | |
| get { return hasField28; } | |
| } | |
| public int Field28 { | |
| get { return field28_; } | |
| } | |
| public const int Field29FieldNumber = 29; | |
| private bool hasField29; | |
| private string field29_ = ""; | |
| public bool HasField29 { | |
| get { return hasField29; } | |
| } | |
| public string Field29 { | |
| get { return field29_; } | |
| } | |
| public const int Field16FieldNumber = 16; | |
| private bool hasField16; | |
| private string field16_ = ""; | |
| public bool HasField16 { | |
| get { return hasField16; } | |
| } | |
| public string Field16 { | |
| get { return field16_; } | |
| } | |
| public const int Field22FieldNumber = 22; | |
| private pbc::PopsicleList<string> field22_ = new pbc::PopsicleList<string>(); | |
| public scg::IList<string> Field22List { | |
| get { return pbc::Lists.AsReadOnly(field22_); } | |
| } | |
| public int Field22Count { | |
| get { return field22_.Count; } | |
| } | |
| public string GetField22(int index) { | |
| return field22_[index]; | |
| } | |
| public const int Field73FieldNumber = 73; | |
| private pbc::PopsicleList<int> field73_ = new pbc::PopsicleList<int>(); | |
| public scg::IList<int> Field73List { | |
| get { return pbc::Lists.AsReadOnly(field73_); } | |
| } | |
| public int Field73Count { | |
| get { return field73_.Count; } | |
| } | |
| public int GetField73(int index) { | |
| return field73_[index]; | |
| } | |
| public const int Field20FieldNumber = 20; | |
| private bool hasField20; | |
| private int field20_ = 0; | |
| public bool HasField20 { | |
| get { return hasField20; } | |
| } | |
| public int Field20 { | |
| get { return field20_; } | |
| } | |
| public const int Field24FieldNumber = 24; | |
| private bool hasField24; | |
| private string field24_ = ""; | |
| public bool HasField24 { | |
| get { return hasField24; } | |
| } | |
| public string Field24 { | |
| get { return field24_; } | |
| } | |
| public const int Field31FieldNumber = 31; | |
| private bool hasField31; | |
| private global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage field31_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance; | |
| public bool HasField31 { | |
| get { return hasField31; } | |
| } | |
| public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage Field31 { | |
| get { return field31_; } | |
| } | |
| public override bool IsInitialized { | |
| get { | |
| if (!hasField11) return false; | |
| if (!hasField15) return false; | |
| return true; | |
| } | |
| } | |
| public override void WriteTo(pb::CodedOutputStream output) { | |
| int size = SerializedSize; | |
| if (HasField5) { | |
| output.WriteInt32(5, "field5", Field5); | |
| } | |
| if (HasField11) { | |
| output.WriteFloat(11, "field11", Field11); | |
| } | |
| if (HasField12) { | |
| output.WriteString(12, "field12", Field12); | |
| } | |
| if (HasField13) { | |
| output.WriteString(13, "field13", Field13); | |
| } | |
| if (field14_.Count > 0) { | |
| output.WriteArray(pbd::FieldType.String, 14, "field14", field14_); | |
| } | |
| if (HasField15) { | |
| output.WriteUInt64(15, "field15", Field15); | |
| } | |
| if (HasField16) { | |
| output.WriteString(16, "field16", Field16); | |
| } | |
| if (HasField20) { | |
| output.WriteInt32(20, "field20", Field20); | |
| } | |
| if (field22_.Count > 0) { | |
| output.WriteArray(pbd::FieldType.String, 22, "field22", field22_); | |
| } | |
| if (HasField24) { | |
| output.WriteString(24, "field24", Field24); | |
| } | |
| if (HasField26) { | |
| output.WriteFloat(26, "field26", Field26); | |
| } | |
| if (HasField27) { | |
| output.WriteString(27, "field27", Field27); | |
| } | |
| if (HasField28) { | |
| output.WriteInt32(28, "field28", Field28); | |
| } | |
| if (HasField29) { | |
| output.WriteString(29, "field29", Field29); | |
| } | |
| if (HasField31) { | |
| output.WriteMessage(31, "field31", Field31); | |
| } | |
| if (field73_.Count > 0) { | |
| output.WriteArray(pbd::FieldType.Int32, 73, "field73", field73_); | |
| } | |
| UnknownFields.WriteTo(output); | |
| } | |
| private int memoizedSerializedSize = -1; | |
| public override int SerializedSize { | |
| get { | |
| int size = memoizedSerializedSize; | |
| if (size != -1) return size; | |
| size = 0; | |
| if (HasField11) { | |
| size += pb::CodedOutputStream.ComputeFloatSize(11, Field11); | |
| } | |
| if (HasField26) { | |
| size += pb::CodedOutputStream.ComputeFloatSize(26, Field26); | |
| } | |
| if (HasField12) { | |
| size += pb::CodedOutputStream.ComputeStringSize(12, Field12); | |
| } | |
| if (HasField13) { | |
| size += pb::CodedOutputStream.ComputeStringSize(13, Field13); | |
| } | |
| { | |
| int dataSize = 0; | |
| foreach (string element in Field14List) { | |
| dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); | |
| } | |
| size += dataSize; | |
| size += 1 * field14_.Count; | |
| } | |
| if (HasField15) { | |
| size += pb::CodedOutputStream.ComputeUInt64Size(15, Field15); | |
| } | |
| if (HasField5) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(5, Field5); | |
| } | |
| if (HasField27) { | |
| size += pb::CodedOutputStream.ComputeStringSize(27, Field27); | |
| } | |
| if (HasField28) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(28, Field28); | |
| } | |
| if (HasField29) { | |
| size += pb::CodedOutputStream.ComputeStringSize(29, Field29); | |
| } | |
| if (HasField16) { | |
| size += pb::CodedOutputStream.ComputeStringSize(16, Field16); | |
| } | |
| { | |
| int dataSize = 0; | |
| foreach (string element in Field22List) { | |
| dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); | |
| } | |
| size += dataSize; | |
| size += 2 * field22_.Count; | |
| } | |
| { | |
| int dataSize = 0; | |
| foreach (int element in Field73List) { | |
| dataSize += pb::CodedOutputStream.ComputeInt32SizeNoTag(element); | |
| } | |
| size += dataSize; | |
| size += 2 * field73_.Count; | |
| } | |
| if (HasField20) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(20, Field20); | |
| } | |
| if (HasField24) { | |
| size += pb::CodedOutputStream.ComputeStringSize(24, Field24); | |
| } | |
| if (HasField31) { | |
| size += pb::CodedOutputStream.ComputeMessageSize(31, Field31); | |
| } | |
| size += UnknownFields.SerializedSize; | |
| memoizedSerializedSize = size; | |
| return size; | |
| } | |
| } | |
| public static Group1 ParseFrom(pb::ByteString data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static Group1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static Group1 ParseFrom(byte[] data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static Group1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static Group1 ParseFrom(global::System.IO.Stream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static Group1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static Group1 ParseDelimitedFrom(global::System.IO.Stream input) { | |
| return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | |
| } | |
| public static Group1 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | |
| } | |
| public static Group1 ParseFrom(pb::CodedInputStream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static Group1 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static Builder CreateBuilder() { return new Builder(); } | |
| public override Builder ToBuilder() { return CreateBuilder(this); } | |
| public override Builder CreateBuilderForType() { return new Builder(); } | |
| public static Builder CreateBuilder(Group1 prototype) { | |
| return (Builder) new Builder().MergeFrom(prototype); | |
| } | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class Builder : pb::GeneratedBuilder<Group1, Builder> { | |
| protected override Builder ThisBuilder { | |
| get { return this; } | |
| } | |
| public Builder() {} | |
| Group1 result = new Group1(); | |
| protected override Group1 MessageBeingBuilt { | |
| get { return result; } | |
| } | |
| public override Builder Clear() { | |
| result = new Group1(); | |
| return this; | |
| } | |
| public override Builder Clone() { | |
| return new Builder().MergeFrom(result); | |
| } | |
| public override pbd::MessageDescriptor DescriptorForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Descriptor; } | |
| } | |
| public override Group1 DefaultInstanceForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.DefaultInstance; } | |
| } | |
| public override Group1 BuildPartial() { | |
| if (result == null) { | |
| throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | |
| } | |
| result.field14_.MakeReadOnly(); | |
| result.field22_.MakeReadOnly(); | |
| result.field73_.MakeReadOnly(); | |
| Group1 returnMe = result; | |
| result = null; | |
| return returnMe; | |
| } | |
| public override Builder MergeFrom(pb::IMessage other) { | |
| if (other is Group1) { | |
| return MergeFrom((Group1) other); | |
| } else { | |
| base.MergeFrom(other); | |
| return this; | |
| } | |
| } | |
| public override Builder MergeFrom(Group1 other) { | |
| if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.DefaultInstance) return this; | |
| if (other.HasField11) { | |
| Field11 = other.Field11; | |
| } | |
| if (other.HasField26) { | |
| Field26 = other.Field26; | |
| } | |
| if (other.HasField12) { | |
| Field12 = other.Field12; | |
| } | |
| if (other.HasField13) { | |
| Field13 = other.Field13; | |
| } | |
| if (other.field14_.Count != 0) { | |
| base.AddRange(other.field14_, result.field14_); | |
| } | |
| if (other.HasField15) { | |
| Field15 = other.Field15; | |
| } | |
| if (other.HasField5) { | |
| Field5 = other.Field5; | |
| } | |
| if (other.HasField27) { | |
| Field27 = other.Field27; | |
| } | |
| if (other.HasField28) { | |
| Field28 = other.Field28; | |
| } | |
| if (other.HasField29) { | |
| Field29 = other.Field29; | |
| } | |
| if (other.HasField16) { | |
| Field16 = other.Field16; | |
| } | |
| if (other.field22_.Count != 0) { | |
| base.AddRange(other.field22_, result.field22_); | |
| } | |
| if (other.field73_.Count != 0) { | |
| base.AddRange(other.field73_, result.field73_); | |
| } | |
| if (other.HasField20) { | |
| Field20 = other.Field20; | |
| } | |
| if (other.HasField24) { | |
| Field24 = other.Field24; | |
| } | |
| if (other.HasField31) { | |
| MergeField31(other.Field31); | |
| } | |
| this.MergeUnknownFields(other.UnknownFields); | |
| return this; | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input) { | |
| return MergeFrom(input, pb::ExtensionRegistry.Empty); | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| pb::UnknownFieldSet.Builder unknownFields = null; | |
| while (true) { | |
| uint tag = input.ReadTag(); | |
| switch (tag) { | |
| case 0: { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| default: { | |
| if (pb::WireFormat.IsEndGroupTag(tag)) { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| if (unknownFields == null) { | |
| unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | |
| } | |
| ParseUnknownField(input, unknownFields, extensionRegistry, tag); | |
| break; | |
| } | |
| case 40: { | |
| Field5 = input.ReadInt32(); | |
| break; | |
| } | |
| case 93: { | |
| Field11 = input.ReadFloat(); | |
| break; | |
| } | |
| case 98: { | |
| Field12 = input.ReadString(); | |
| break; | |
| } | |
| case 106: { | |
| Field13 = input.ReadString(); | |
| break; | |
| } | |
| case 114: { | |
| AddField14(input.ReadString()); | |
| break; | |
| } | |
| case 120: { | |
| Field15 = input.ReadUInt64(); | |
| break; | |
| } | |
| case 130: { | |
| Field16 = input.ReadString(); | |
| break; | |
| } | |
| case 160: { | |
| Field20 = input.ReadInt32(); | |
| break; | |
| } | |
| case 178: { | |
| AddField22(input.ReadString()); | |
| break; | |
| } | |
| case 194: { | |
| Field24 = input.ReadString(); | |
| break; | |
| } | |
| case 213: { | |
| Field26 = input.ReadFloat(); | |
| break; | |
| } | |
| case 218: { | |
| Field27 = input.ReadString(); | |
| break; | |
| } | |
| case 224: { | |
| Field28 = input.ReadInt32(); | |
| break; | |
| } | |
| case 234: { | |
| Field29 = input.ReadString(); | |
| break; | |
| } | |
| case 250: { | |
| global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.CreateBuilder(); | |
| if (HasField31) { | |
| subBuilder.MergeFrom(Field31); | |
| } | |
| input.ReadMessage(subBuilder, extensionRegistry); | |
| Field31 = subBuilder.BuildPartial(); | |
| break; | |
| } | |
| case 584: { | |
| AddField73(input.ReadInt32()); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| public bool HasField11 { | |
| get { return result.HasField11; } | |
| } | |
| public float Field11 { | |
| get { return result.Field11; } | |
| set { SetField11(value); } | |
| } | |
| public Builder SetField11(float value) { | |
| result.hasField11 = true; | |
| result.field11_ = value; | |
| return this; | |
| } | |
| public Builder ClearField11() { | |
| result.hasField11 = false; | |
| result.field11_ = 0F; | |
| return this; | |
| } | |
| public bool HasField26 { | |
| get { return result.HasField26; } | |
| } | |
| public float Field26 { | |
| get { return result.Field26; } | |
| set { SetField26(value); } | |
| } | |
| public Builder SetField26(float value) { | |
| result.hasField26 = true; | |
| result.field26_ = value; | |
| return this; | |
| } | |
| public Builder ClearField26() { | |
| result.hasField26 = false; | |
| result.field26_ = 0F; | |
| return this; | |
| } | |
| public bool HasField12 { | |
| get { return result.HasField12; } | |
| } | |
| public string Field12 { | |
| get { return result.Field12; } | |
| set { SetField12(value); } | |
| } | |
| public Builder SetField12(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField12 = true; | |
| result.field12_ = value; | |
| return this; | |
| } | |
| public Builder ClearField12() { | |
| result.hasField12 = false; | |
| result.field12_ = ""; | |
| return this; | |
| } | |
| public bool HasField13 { | |
| get { return result.HasField13; } | |
| } | |
| public string Field13 { | |
| get { return result.Field13; } | |
| set { SetField13(value); } | |
| } | |
| public Builder SetField13(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField13 = true; | |
| result.field13_ = value; | |
| return this; | |
| } | |
| public Builder ClearField13() { | |
| result.hasField13 = false; | |
| result.field13_ = ""; | |
| return this; | |
| } | |
| public pbc::IPopsicleList<string> Field14List { | |
| get { return result.field14_; } | |
| } | |
| public int Field14Count { | |
| get { return result.Field14Count; } | |
| } | |
| public string GetField14(int index) { | |
| return result.GetField14(index); | |
| } | |
| public Builder SetField14(int index, string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.field14_[index] = value; | |
| return this; | |
| } | |
| public Builder AddField14(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.field14_.Add(value); | |
| return this; | |
| } | |
| public Builder AddRangeField14(scg::IEnumerable<string> values) { | |
| base.AddRange(values, result.field14_); | |
| return this; | |
| } | |
| public Builder ClearField14() { | |
| result.field14_.Clear(); | |
| return this; | |
| } | |
| public bool HasField15 { | |
| get { return result.HasField15; } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public ulong Field15 { | |
| get { return result.Field15; } | |
| set { SetField15(value); } | |
| } | |
| [global::System.CLSCompliant(false)] | |
| public Builder SetField15(ulong value) { | |
| result.hasField15 = true; | |
| result.field15_ = value; | |
| return this; | |
| } | |
| public Builder ClearField15() { | |
| result.hasField15 = false; | |
| result.field15_ = 0UL; | |
| return this; | |
| } | |
| public bool HasField5 { | |
| get { return result.HasField5; } | |
| } | |
| public int Field5 { | |
| get { return result.Field5; } | |
| set { SetField5(value); } | |
| } | |
| public Builder SetField5(int value) { | |
| result.hasField5 = true; | |
| result.field5_ = value; | |
| return this; | |
| } | |
| public Builder ClearField5() { | |
| result.hasField5 = false; | |
| result.field5_ = 0; | |
| return this; | |
| } | |
| public bool HasField27 { | |
| get { return result.HasField27; } | |
| } | |
| public string Field27 { | |
| get { return result.Field27; } | |
| set { SetField27(value); } | |
| } | |
| public Builder SetField27(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField27 = true; | |
| result.field27_ = value; | |
| return this; | |
| } | |
| public Builder ClearField27() { | |
| result.hasField27 = false; | |
| result.field27_ = ""; | |
| return this; | |
| } | |
| public bool HasField28 { | |
| get { return result.HasField28; } | |
| } | |
| public int Field28 { | |
| get { return result.Field28; } | |
| set { SetField28(value); } | |
| } | |
| public Builder SetField28(int value) { | |
| result.hasField28 = true; | |
| result.field28_ = value; | |
| return this; | |
| } | |
| public Builder ClearField28() { | |
| result.hasField28 = false; | |
| result.field28_ = 0; | |
| return this; | |
| } | |
| public bool HasField29 { | |
| get { return result.HasField29; } | |
| } | |
| public string Field29 { | |
| get { return result.Field29; } | |
| set { SetField29(value); } | |
| } | |
| public Builder SetField29(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField29 = true; | |
| result.field29_ = value; | |
| return this; | |
| } | |
| public Builder ClearField29() { | |
| result.hasField29 = false; | |
| result.field29_ = ""; | |
| return this; | |
| } | |
| public bool HasField16 { | |
| get { return result.HasField16; } | |
| } | |
| public string Field16 { | |
| get { return result.Field16; } | |
| set { SetField16(value); } | |
| } | |
| public Builder SetField16(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField16 = true; | |
| result.field16_ = value; | |
| return this; | |
| } | |
| public Builder ClearField16() { | |
| result.hasField16 = false; | |
| result.field16_ = ""; | |
| return this; | |
| } | |
| public pbc::IPopsicleList<string> Field22List { | |
| get { return result.field22_; } | |
| } | |
| public int Field22Count { | |
| get { return result.Field22Count; } | |
| } | |
| public string GetField22(int index) { | |
| return result.GetField22(index); | |
| } | |
| public Builder SetField22(int index, string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.field22_[index] = value; | |
| return this; | |
| } | |
| public Builder AddField22(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.field22_.Add(value); | |
| return this; | |
| } | |
| public Builder AddRangeField22(scg::IEnumerable<string> values) { | |
| base.AddRange(values, result.field22_); | |
| return this; | |
| } | |
| public Builder ClearField22() { | |
| result.field22_.Clear(); | |
| return this; | |
| } | |
| public pbc::IPopsicleList<int> Field73List { | |
| get { return result.field73_; } | |
| } | |
| public int Field73Count { | |
| get { return result.Field73Count; } | |
| } | |
| public int GetField73(int index) { | |
| return result.GetField73(index); | |
| } | |
| public Builder SetField73(int index, int value) { | |
| result.field73_[index] = value; | |
| return this; | |
| } | |
| public Builder AddField73(int value) { | |
| result.field73_.Add(value); | |
| return this; | |
| } | |
| public Builder AddRangeField73(scg::IEnumerable<int> values) { | |
| base.AddRange(values, result.field73_); | |
| return this; | |
| } | |
| public Builder ClearField73() { | |
| result.field73_.Clear(); | |
| return this; | |
| } | |
| public bool HasField20 { | |
| get { return result.HasField20; } | |
| } | |
| public int Field20 { | |
| get { return result.Field20; } | |
| set { SetField20(value); } | |
| } | |
| public Builder SetField20(int value) { | |
| result.hasField20 = true; | |
| result.field20_ = value; | |
| return this; | |
| } | |
| public Builder ClearField20() { | |
| result.hasField20 = false; | |
| result.field20_ = 0; | |
| return this; | |
| } | |
| public bool HasField24 { | |
| get { return result.HasField24; } | |
| } | |
| public string Field24 { | |
| get { return result.Field24; } | |
| set { SetField24(value); } | |
| } | |
| public Builder SetField24(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField24 = true; | |
| result.field24_ = value; | |
| return this; | |
| } | |
| public Builder ClearField24() { | |
| result.hasField24 = false; | |
| result.field24_ = ""; | |
| return this; | |
| } | |
| public bool HasField31 { | |
| get { return result.HasField31; } | |
| } | |
| public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage Field31 { | |
| get { return result.Field31; } | |
| set { SetField31(value); } | |
| } | |
| public Builder SetField31(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField31 = true; | |
| result.field31_ = value; | |
| return this; | |
| } | |
| public Builder SetField31(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder builderForValue) { | |
| pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | |
| result.hasField31 = true; | |
| result.field31_ = builderForValue.Build(); | |
| return this; | |
| } | |
| public Builder MergeField31(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| if (result.HasField31 && | |
| result.field31_ != global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance) { | |
| result.field31_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.CreateBuilder(result.field31_).MergeFrom(value).BuildPartial(); | |
| } else { | |
| result.field31_ = value; | |
| } | |
| result.hasField31 = true; | |
| return this; | |
| } | |
| public Builder ClearField31() { | |
| result.hasField31 = false; | |
| result.field31_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance; | |
| return this; | |
| } | |
| } | |
| static Group1() { | |
| object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null); | |
| } | |
| } | |
| } | |
| #endregion | |
| public const int Field1FieldNumber = 1; | |
| private bool hasField1; | |
| private string field1_ = ""; | |
| public bool HasField1 { | |
| get { return hasField1; } | |
| } | |
| public string Field1 { | |
| get { return field1_; } | |
| } | |
| public const int Field3FieldNumber = 3; | |
| private bool hasField3; | |
| private long field3_ = 0L; | |
| public bool HasField3 { | |
| get { return hasField3; } | |
| } | |
| public long Field3 { | |
| get { return field3_; } | |
| } | |
| public const int Field4FieldNumber = 4; | |
| private bool hasField4; | |
| private long field4_ = 0L; | |
| public bool HasField4 { | |
| get { return hasField4; } | |
| } | |
| public long Field4 { | |
| get { return field4_; } | |
| } | |
| public const int Field30FieldNumber = 30; | |
| private bool hasField30; | |
| private long field30_ = 0L; | |
| public bool HasField30 { | |
| get { return hasField30; } | |
| } | |
| public long Field30 { | |
| get { return field30_; } | |
| } | |
| public const int Field75FieldNumber = 75; | |
| private bool hasField75; | |
| private bool field75_ = false; | |
| public bool HasField75 { | |
| get { return hasField75; } | |
| } | |
| public bool Field75 { | |
| get { return field75_; } | |
| } | |
| public const int Field6FieldNumber = 6; | |
| private bool hasField6; | |
| private string field6_ = ""; | |
| public bool HasField6 { | |
| get { return hasField6; } | |
| } | |
| public string Field6 { | |
| get { return field6_; } | |
| } | |
| public const int Field2FieldNumber = 2; | |
| private bool hasField2; | |
| private pb::ByteString field2_ = pb::ByteString.Empty; | |
| public bool HasField2 { | |
| get { return hasField2; } | |
| } | |
| public pb::ByteString Field2 { | |
| get { return field2_; } | |
| } | |
| public const int Field21FieldNumber = 21; | |
| private bool hasField21; | |
| private int field21_ = 0; | |
| public bool HasField21 { | |
| get { return hasField21; } | |
| } | |
| public int Field21 { | |
| get { return field21_; } | |
| } | |
| public const int Field71FieldNumber = 71; | |
| private bool hasField71; | |
| private int field71_ = 0; | |
| public bool HasField71 { | |
| get { return hasField71; } | |
| } | |
| public int Field71 { | |
| get { return field71_; } | |
| } | |
| public const int Field25FieldNumber = 25; | |
| private bool hasField25; | |
| private float field25_ = 0F; | |
| public bool HasField25 { | |
| get { return hasField25; } | |
| } | |
| public float Field25 { | |
| get { return field25_; } | |
| } | |
| public const int Field109FieldNumber = 109; | |
| private bool hasField109; | |
| private int field109_ = 0; | |
| public bool HasField109 { | |
| get { return hasField109; } | |
| } | |
| public int Field109 { | |
| get { return field109_; } | |
| } | |
| public const int Field210FieldNumber = 210; | |
| private bool hasField210; | |
| private int field210_ = 0; | |
| public bool HasField210 { | |
| get { return hasField210; } | |
| } | |
| public int Field210 { | |
| get { return field210_; } | |
| } | |
| public const int Field211FieldNumber = 211; | |
| private bool hasField211; | |
| private int field211_ = 0; | |
| public bool HasField211 { | |
| get { return hasField211; } | |
| } | |
| public int Field211 { | |
| get { return field211_; } | |
| } | |
| public const int Field212FieldNumber = 212; | |
| private bool hasField212; | |
| private int field212_ = 0; | |
| public bool HasField212 { | |
| get { return hasField212; } | |
| } | |
| public int Field212 { | |
| get { return field212_; } | |
| } | |
| public const int Field213FieldNumber = 213; | |
| private bool hasField213; | |
| private int field213_ = 0; | |
| public bool HasField213 { | |
| get { return hasField213; } | |
| } | |
| public int Field213 { | |
| get { return field213_; } | |
| } | |
| public const int Field216FieldNumber = 216; | |
| private bool hasField216; | |
| private int field216_ = 0; | |
| public bool HasField216 { | |
| get { return hasField216; } | |
| } | |
| public int Field216 { | |
| get { return field216_; } | |
| } | |
| public const int Field217FieldNumber = 217; | |
| private bool hasField217; | |
| private int field217_ = 0; | |
| public bool HasField217 { | |
| get { return hasField217; } | |
| } | |
| public int Field217 { | |
| get { return field217_; } | |
| } | |
| public const int Field218FieldNumber = 218; | |
| private bool hasField218; | |
| private int field218_ = 0; | |
| public bool HasField218 { | |
| get { return hasField218; } | |
| } | |
| public int Field218 { | |
| get { return field218_; } | |
| } | |
| public const int Field220FieldNumber = 220; | |
| private bool hasField220; | |
| private int field220_ = 0; | |
| public bool HasField220 { | |
| get { return hasField220; } | |
| } | |
| public int Field220 { | |
| get { return field220_; } | |
| } | |
| public const int Field221FieldNumber = 221; | |
| private bool hasField221; | |
| private int field221_ = 0; | |
| public bool HasField221 { | |
| get { return hasField221; } | |
| } | |
| public int Field221 { | |
| get { return field221_; } | |
| } | |
| public const int Field222FieldNumber = 222; | |
| private bool hasField222; | |
| private float field222_ = 0F; | |
| public bool HasField222 { | |
| get { return hasField222; } | |
| } | |
| public float Field222 { | |
| get { return field222_; } | |
| } | |
| public const int Field63FieldNumber = 63; | |
| private bool hasField63; | |
| private int field63_ = 0; | |
| public bool HasField63 { | |
| get { return hasField63; } | |
| } | |
| public int Field63 { | |
| get { return field63_; } | |
| } | |
| public const int Group1FieldNumber = 10; | |
| private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1> group1_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1>(); | |
| public scg::IList<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1> Group1List { | |
| get { return group1_; } | |
| } | |
| public int Group1Count { | |
| get { return group1_.Count; } | |
| } | |
| public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 GetGroup1(int index) { | |
| return group1_[index]; | |
| } | |
| public const int Field128FieldNumber = 128; | |
| private pbc::PopsicleList<string> field128_ = new pbc::PopsicleList<string>(); | |
| public scg::IList<string> Field128List { | |
| get { return pbc::Lists.AsReadOnly(field128_); } | |
| } | |
| public int Field128Count { | |
| get { return field128_.Count; } | |
| } | |
| public string GetField128(int index) { | |
| return field128_[index]; | |
| } | |
| public const int Field131FieldNumber = 131; | |
| private bool hasField131; | |
| private long field131_ = 0L; | |
| public bool HasField131 { | |
| get { return hasField131; } | |
| } | |
| public long Field131 { | |
| get { return field131_; } | |
| } | |
| public const int Field127FieldNumber = 127; | |
| private pbc::PopsicleList<string> field127_ = new pbc::PopsicleList<string>(); | |
| public scg::IList<string> Field127List { | |
| get { return pbc::Lists.AsReadOnly(field127_); } | |
| } | |
| public int Field127Count { | |
| get { return field127_.Count; } | |
| } | |
| public string GetField127(int index) { | |
| return field127_[index]; | |
| } | |
| public const int Field129FieldNumber = 129; | |
| private bool hasField129; | |
| private int field129_ = 0; | |
| public bool HasField129 { | |
| get { return hasField129; } | |
| } | |
| public int Field129 { | |
| get { return field129_; } | |
| } | |
| public const int Field130FieldNumber = 130; | |
| private pbc::PopsicleList<long> field130_ = new pbc::PopsicleList<long>(); | |
| public scg::IList<long> Field130List { | |
| get { return pbc::Lists.AsReadOnly(field130_); } | |
| } | |
| public int Field130Count { | |
| get { return field130_.Count; } | |
| } | |
| public long GetField130(int index) { | |
| return field130_[index]; | |
| } | |
| public const int Field205FieldNumber = 205; | |
| private bool hasField205; | |
| private bool field205_ = false; | |
| public bool HasField205 { | |
| get { return hasField205; } | |
| } | |
| public bool Field205 { | |
| get { return field205_; } | |
| } | |
| public const int Field206FieldNumber = 206; | |
| private bool hasField206; | |
| private bool field206_ = false; | |
| public bool HasField206 { | |
| get { return hasField206; } | |
| } | |
| public bool Field206 { | |
| get { return field206_; } | |
| } | |
| public override bool IsInitialized { | |
| get { | |
| return true; | |
| } | |
| } | |
| public override void WriteTo(pb::CodedOutputStream output) { | |
| int size = SerializedSize; | |
| if (HasField1) { | |
| output.WriteString(1, "field1", Field1); | |
| } | |
| if (HasField2) { | |
| output.WriteBytes(2, "field2", Field2); | |
| } | |
| if (HasField3) { | |
| output.WriteInt64(3, "field3", Field3); | |
| } | |
| if (HasField4) { | |
| output.WriteInt64(4, "field4", Field4); | |
| } | |
| if (HasField6) { | |
| output.WriteString(6, "field6", Field6); | |
| } | |
| if (group1_.Count > 0) { | |
| output.WriteGroupArray(10, "group1", group1_); | |
| } | |
| if (HasField21) { | |
| output.WriteInt32(21, "field21", Field21); | |
| } | |
| if (HasField25) { | |
| output.WriteFloat(25, "field25", Field25); | |
| } | |
| if (HasField30) { | |
| output.WriteInt64(30, "field30", Field30); | |
| } | |
| if (HasField63) { | |
| output.WriteInt32(63, "field63", Field63); | |
| } | |
| if (HasField71) { | |
| output.WriteInt32(71, "field71", Field71); | |
| } | |
| if (HasField75) { | |
| output.WriteBool(75, "field75", Field75); | |
| } | |
| if (HasField109) { | |
| output.WriteInt32(109, "field109", Field109); | |
| } | |
| if (field127_.Count > 0) { | |
| output.WriteArray(pbd::FieldType.String, 127, "field127", field127_); | |
| } | |
| if (field128_.Count > 0) { | |
| output.WriteArray(pbd::FieldType.String, 128, "field128", field128_); | |
| } | |
| if (HasField129) { | |
| output.WriteInt32(129, "field129", Field129); | |
| } | |
| if (field130_.Count > 0) { | |
| output.WriteArray(pbd::FieldType.Int64, 130, "field130", field130_); | |
| } | |
| if (HasField131) { | |
| output.WriteInt64(131, "field131", Field131); | |
| } | |
| if (HasField205) { | |
| output.WriteBool(205, "field205", Field205); | |
| } | |
| if (HasField206) { | |
| output.WriteBool(206, "field206", Field206); | |
| } | |
| if (HasField210) { | |
| output.WriteInt32(210, "field210", Field210); | |
| } | |
| if (HasField211) { | |
| output.WriteInt32(211, "field211", Field211); | |
| } | |
| if (HasField212) { | |
| output.WriteInt32(212, "field212", Field212); | |
| } | |
| if (HasField213) { | |
| output.WriteInt32(213, "field213", Field213); | |
| } | |
| if (HasField216) { | |
| output.WriteInt32(216, "field216", Field216); | |
| } | |
| if (HasField217) { | |
| output.WriteInt32(217, "field217", Field217); | |
| } | |
| if (HasField218) { | |
| output.WriteInt32(218, "field218", Field218); | |
| } | |
| if (HasField220) { | |
| output.WriteInt32(220, "field220", Field220); | |
| } | |
| if (HasField221) { | |
| output.WriteInt32(221, "field221", Field221); | |
| } | |
| if (HasField222) { | |
| output.WriteFloat(222, "field222", Field222); | |
| } | |
| UnknownFields.WriteTo(output); | |
| } | |
| private int memoizedSerializedSize = -1; | |
| public override int SerializedSize { | |
| get { | |
| int size = memoizedSerializedSize; | |
| if (size != -1) return size; | |
| size = 0; | |
| if (HasField1) { | |
| size += pb::CodedOutputStream.ComputeStringSize(1, Field1); | |
| } | |
| if (HasField3) { | |
| size += pb::CodedOutputStream.ComputeInt64Size(3, Field3); | |
| } | |
| if (HasField4) { | |
| size += pb::CodedOutputStream.ComputeInt64Size(4, Field4); | |
| } | |
| if (HasField30) { | |
| size += pb::CodedOutputStream.ComputeInt64Size(30, Field30); | |
| } | |
| if (HasField75) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(75, Field75); | |
| } | |
| if (HasField6) { | |
| size += pb::CodedOutputStream.ComputeStringSize(6, Field6); | |
| } | |
| if (HasField2) { | |
| size += pb::CodedOutputStream.ComputeBytesSize(2, Field2); | |
| } | |
| if (HasField21) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(21, Field21); | |
| } | |
| if (HasField71) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(71, Field71); | |
| } | |
| if (HasField25) { | |
| size += pb::CodedOutputStream.ComputeFloatSize(25, Field25); | |
| } | |
| if (HasField109) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(109, Field109); | |
| } | |
| if (HasField210) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(210, Field210); | |
| } | |
| if (HasField211) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(211, Field211); | |
| } | |
| if (HasField212) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(212, Field212); | |
| } | |
| if (HasField213) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(213, Field213); | |
| } | |
| if (HasField216) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(216, Field216); | |
| } | |
| if (HasField217) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(217, Field217); | |
| } | |
| if (HasField218) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(218, Field218); | |
| } | |
| if (HasField220) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(220, Field220); | |
| } | |
| if (HasField221) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(221, Field221); | |
| } | |
| if (HasField222) { | |
| size += pb::CodedOutputStream.ComputeFloatSize(222, Field222); | |
| } | |
| if (HasField63) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(63, Field63); | |
| } | |
| foreach (global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 element in Group1List) { | |
| size += pb::CodedOutputStream.ComputeGroupSize(10, element); | |
| } | |
| { | |
| int dataSize = 0; | |
| foreach (string element in Field128List) { | |
| dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); | |
| } | |
| size += dataSize; | |
| size += 2 * field128_.Count; | |
| } | |
| if (HasField131) { | |
| size += pb::CodedOutputStream.ComputeInt64Size(131, Field131); | |
| } | |
| { | |
| int dataSize = 0; | |
| foreach (string element in Field127List) { | |
| dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element); | |
| } | |
| size += dataSize; | |
| size += 2 * field127_.Count; | |
| } | |
| if (HasField129) { | |
| size += pb::CodedOutputStream.ComputeInt32Size(129, Field129); | |
| } | |
| { | |
| int dataSize = 0; | |
| foreach (long element in Field130List) { | |
| dataSize += pb::CodedOutputStream.ComputeInt64SizeNoTag(element); | |
| } | |
| size += dataSize; | |
| size += 2 * field130_.Count; | |
| } | |
| if (HasField205) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(205, Field205); | |
| } | |
| if (HasField206) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(206, Field206); | |
| } | |
| size += UnknownFields.SerializedSize; | |
| memoizedSerializedSize = size; | |
| return size; | |
| } | |
| } | |
| public static SpeedMessage2 ParseFrom(pb::ByteString data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static SpeedMessage2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage2 ParseFrom(byte[] data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static SpeedMessage2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage2 ParseFrom(global::System.IO.Stream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static SpeedMessage2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage2 ParseDelimitedFrom(global::System.IO.Stream input) { | |
| return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | |
| } | |
| public static SpeedMessage2 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | |
| } | |
| public static SpeedMessage2 ParseFrom(pb::CodedInputStream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static SpeedMessage2 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static Builder CreateBuilder() { return new Builder(); } | |
| public override Builder ToBuilder() { return CreateBuilder(this); } | |
| public override Builder CreateBuilderForType() { return new Builder(); } | |
| public static Builder CreateBuilder(SpeedMessage2 prototype) { | |
| return (Builder) new Builder().MergeFrom(prototype); | |
| } | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class Builder : pb::GeneratedBuilder<SpeedMessage2, Builder> { | |
| protected override Builder ThisBuilder { | |
| get { return this; } | |
| } | |
| public Builder() {} | |
| SpeedMessage2 result = new SpeedMessage2(); | |
| protected override SpeedMessage2 MessageBeingBuilt { | |
| get { return result; } | |
| } | |
| public override Builder Clear() { | |
| result = new SpeedMessage2(); | |
| return this; | |
| } | |
| public override Builder Clone() { | |
| return new Builder().MergeFrom(result); | |
| } | |
| public override pbd::MessageDescriptor DescriptorForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Descriptor; } | |
| } | |
| public override SpeedMessage2 DefaultInstanceForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.DefaultInstance; } | |
| } | |
| public override SpeedMessage2 BuildPartial() { | |
| if (result == null) { | |
| throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | |
| } | |
| result.group1_.MakeReadOnly(); | |
| result.field128_.MakeReadOnly(); | |
| result.field127_.MakeReadOnly(); | |
| result.field130_.MakeReadOnly(); | |
| SpeedMessage2 returnMe = result; | |
| result = null; | |
| return returnMe; | |
| } | |
| public override Builder MergeFrom(pb::IMessage other) { | |
| if (other is SpeedMessage2) { | |
| return MergeFrom((SpeedMessage2) other); | |
| } else { | |
| base.MergeFrom(other); | |
| return this; | |
| } | |
| } | |
| public override Builder MergeFrom(SpeedMessage2 other) { | |
| if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.DefaultInstance) return this; | |
| if (other.HasField1) { | |
| Field1 = other.Field1; | |
| } | |
| if (other.HasField3) { | |
| Field3 = other.Field3; | |
| } | |
| if (other.HasField4) { | |
| Field4 = other.Field4; | |
| } | |
| if (other.HasField30) { | |
| Field30 = other.Field30; | |
| } | |
| if (other.HasField75) { | |
| Field75 = other.Field75; | |
| } | |
| if (other.HasField6) { | |
| Field6 = other.Field6; | |
| } | |
| if (other.HasField2) { | |
| Field2 = other.Field2; | |
| } | |
| if (other.HasField21) { | |
| Field21 = other.Field21; | |
| } | |
| if (other.HasField71) { | |
| Field71 = other.Field71; | |
| } | |
| if (other.HasField25) { | |
| Field25 = other.Field25; | |
| } | |
| if (other.HasField109) { | |
| Field109 = other.Field109; | |
| } | |
| if (other.HasField210) { | |
| Field210 = other.Field210; | |
| } | |
| if (other.HasField211) { | |
| Field211 = other.Field211; | |
| } | |
| if (other.HasField212) { | |
| Field212 = other.Field212; | |
| } | |
| if (other.HasField213) { | |
| Field213 = other.Field213; | |
| } | |
| if (other.HasField216) { | |
| Field216 = other.Field216; | |
| } | |
| if (other.HasField217) { | |
| Field217 = other.Field217; | |
| } | |
| if (other.HasField218) { | |
| Field218 = other.Field218; | |
| } | |
| if (other.HasField220) { | |
| Field220 = other.Field220; | |
| } | |
| if (other.HasField221) { | |
| Field221 = other.Field221; | |
| } | |
| if (other.HasField222) { | |
| Field222 = other.Field222; | |
| } | |
| if (other.HasField63) { | |
| Field63 = other.Field63; | |
| } | |
| if (other.group1_.Count != 0) { | |
| base.AddRange(other.group1_, result.group1_); | |
| } | |
| if (other.field128_.Count != 0) { | |
| base.AddRange(other.field128_, result.field128_); | |
| } | |
| if (other.HasField131) { | |
| Field131 = other.Field131; | |
| } | |
| if (other.field127_.Count != 0) { | |
| base.AddRange(other.field127_, result.field127_); | |
| } | |
| if (other.HasField129) { | |
| Field129 = other.Field129; | |
| } | |
| if (other.field130_.Count != 0) { | |
| base.AddRange(other.field130_, result.field130_); | |
| } | |
| if (other.HasField205) { | |
| Field205 = other.Field205; | |
| } | |
| if (other.HasField206) { | |
| Field206 = other.Field206; | |
| } | |
| this.MergeUnknownFields(other.UnknownFields); | |
| return this; | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input) { | |
| return MergeFrom(input, pb::ExtensionRegistry.Empty); | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| pb::UnknownFieldSet.Builder unknownFields = null; | |
| while (true) { | |
| uint tag = input.ReadTag(); | |
| switch (tag) { | |
| case 0: { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| default: { | |
| if (pb::WireFormat.IsEndGroupTag(tag)) { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| if (unknownFields == null) { | |
| unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | |
| } | |
| ParseUnknownField(input, unknownFields, extensionRegistry, tag); | |
| break; | |
| } | |
| case 10: { | |
| Field1 = input.ReadString(); | |
| break; | |
| } | |
| case 18: { | |
| Field2 = input.ReadBytes(); | |
| break; | |
| } | |
| case 24: { | |
| Field3 = input.ReadInt64(); | |
| break; | |
| } | |
| case 32: { | |
| Field4 = input.ReadInt64(); | |
| break; | |
| } | |
| case 50: { | |
| Field6 = input.ReadString(); | |
| break; | |
| } | |
| case 83: { | |
| global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.CreateBuilder(); | |
| input.ReadGroup(10, subBuilder, extensionRegistry); | |
| AddGroup1(subBuilder.BuildPartial()); | |
| break; | |
| } | |
| case 168: { | |
| Field21 = input.ReadInt32(); | |
| break; | |
| } | |
| case 205: { | |
| Field25 = input.ReadFloat(); | |
| break; | |
| } | |
| case 240: { | |
| Field30 = input.ReadInt64(); | |
| break; | |
| } | |
| case 504: { | |
| Field63 = input.ReadInt32(); | |
| break; | |
| } | |
| case 568: { | |
| Field71 = input.ReadInt32(); | |
| break; | |
| } | |
| case 600: { | |
| Field75 = input.ReadBool(); | |
| break; | |
| } | |
| case 872: { | |
| Field109 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1018: { | |
| AddField127(input.ReadString()); | |
| break; | |
| } | |
| case 1026: { | |
| AddField128(input.ReadString()); | |
| break; | |
| } | |
| case 1032: { | |
| Field129 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1040: { | |
| AddField130(input.ReadInt64()); | |
| break; | |
| } | |
| case 1048: { | |
| Field131 = input.ReadInt64(); | |
| break; | |
| } | |
| case 1640: { | |
| Field205 = input.ReadBool(); | |
| break; | |
| } | |
| case 1648: { | |
| Field206 = input.ReadBool(); | |
| break; | |
| } | |
| case 1680: { | |
| Field210 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1688: { | |
| Field211 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1696: { | |
| Field212 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1704: { | |
| Field213 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1728: { | |
| Field216 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1736: { | |
| Field217 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1744: { | |
| Field218 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1760: { | |
| Field220 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1768: { | |
| Field221 = input.ReadInt32(); | |
| break; | |
| } | |
| case 1781: { | |
| Field222 = input.ReadFloat(); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| public bool HasField1 { | |
| get { return result.HasField1; } | |
| } | |
| public string Field1 { | |
| get { return result.Field1; } | |
| set { SetField1(value); } | |
| } | |
| public Builder SetField1(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField1 = true; | |
| result.field1_ = value; | |
| return this; | |
| } | |
| public Builder ClearField1() { | |
| result.hasField1 = false; | |
| result.field1_ = ""; | |
| return this; | |
| } | |
| public bool HasField3 { | |
| get { return result.HasField3; } | |
| } | |
| public long Field3 { | |
| get { return result.Field3; } | |
| set { SetField3(value); } | |
| } | |
| public Builder SetField3(long value) { | |
| result.hasField3 = true; | |
| result.field3_ = value; | |
| return this; | |
| } | |
| public Builder ClearField3() { | |
| result.hasField3 = false; | |
| result.field3_ = 0L; | |
| return this; | |
| } | |
| public bool HasField4 { | |
| get { return result.HasField4; } | |
| } | |
| public long Field4 { | |
| get { return result.Field4; } | |
| set { SetField4(value); } | |
| } | |
| public Builder SetField4(long value) { | |
| result.hasField4 = true; | |
| result.field4_ = value; | |
| return this; | |
| } | |
| public Builder ClearField4() { | |
| result.hasField4 = false; | |
| result.field4_ = 0L; | |
| return this; | |
| } | |
| public bool HasField30 { | |
| get { return result.HasField30; } | |
| } | |
| public long Field30 { | |
| get { return result.Field30; } | |
| set { SetField30(value); } | |
| } | |
| public Builder SetField30(long value) { | |
| result.hasField30 = true; | |
| result.field30_ = value; | |
| return this; | |
| } | |
| public Builder ClearField30() { | |
| result.hasField30 = false; | |
| result.field30_ = 0L; | |
| return this; | |
| } | |
| public bool HasField75 { | |
| get { return result.HasField75; } | |
| } | |
| public bool Field75 { | |
| get { return result.Field75; } | |
| set { SetField75(value); } | |
| } | |
| public Builder SetField75(bool value) { | |
| result.hasField75 = true; | |
| result.field75_ = value; | |
| return this; | |
| } | |
| public Builder ClearField75() { | |
| result.hasField75 = false; | |
| result.field75_ = false; | |
| return this; | |
| } | |
| public bool HasField6 { | |
| get { return result.HasField6; } | |
| } | |
| public string Field6 { | |
| get { return result.Field6; } | |
| set { SetField6(value); } | |
| } | |
| public Builder SetField6(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField6 = true; | |
| result.field6_ = value; | |
| return this; | |
| } | |
| public Builder ClearField6() { | |
| result.hasField6 = false; | |
| result.field6_ = ""; | |
| return this; | |
| } | |
| public bool HasField2 { | |
| get { return result.HasField2; } | |
| } | |
| public pb::ByteString Field2 { | |
| get { return result.Field2; } | |
| set { SetField2(value); } | |
| } | |
| public Builder SetField2(pb::ByteString value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.hasField2 = true; | |
| result.field2_ = value; | |
| return this; | |
| } | |
| public Builder ClearField2() { | |
| result.hasField2 = false; | |
| result.field2_ = pb::ByteString.Empty; | |
| return this; | |
| } | |
| public bool HasField21 { | |
| get { return result.HasField21; } | |
| } | |
| public int Field21 { | |
| get { return result.Field21; } | |
| set { SetField21(value); } | |
| } | |
| public Builder SetField21(int value) { | |
| result.hasField21 = true; | |
| result.field21_ = value; | |
| return this; | |
| } | |
| public Builder ClearField21() { | |
| result.hasField21 = false; | |
| result.field21_ = 0; | |
| return this; | |
| } | |
| public bool HasField71 { | |
| get { return result.HasField71; } | |
| } | |
| public int Field71 { | |
| get { return result.Field71; } | |
| set { SetField71(value); } | |
| } | |
| public Builder SetField71(int value) { | |
| result.hasField71 = true; | |
| result.field71_ = value; | |
| return this; | |
| } | |
| public Builder ClearField71() { | |
| result.hasField71 = false; | |
| result.field71_ = 0; | |
| return this; | |
| } | |
| public bool HasField25 { | |
| get { return result.HasField25; } | |
| } | |
| public float Field25 { | |
| get { return result.Field25; } | |
| set { SetField25(value); } | |
| } | |
| public Builder SetField25(float value) { | |
| result.hasField25 = true; | |
| result.field25_ = value; | |
| return this; | |
| } | |
| public Builder ClearField25() { | |
| result.hasField25 = false; | |
| result.field25_ = 0F; | |
| return this; | |
| } | |
| public bool HasField109 { | |
| get { return result.HasField109; } | |
| } | |
| public int Field109 { | |
| get { return result.Field109; } | |
| set { SetField109(value); } | |
| } | |
| public Builder SetField109(int value) { | |
| result.hasField109 = true; | |
| result.field109_ = value; | |
| return this; | |
| } | |
| public Builder ClearField109() { | |
| result.hasField109 = false; | |
| result.field109_ = 0; | |
| return this; | |
| } | |
| public bool HasField210 { | |
| get { return result.HasField210; } | |
| } | |
| public int Field210 { | |
| get { return result.Field210; } | |
| set { SetField210(value); } | |
| } | |
| public Builder SetField210(int value) { | |
| result.hasField210 = true; | |
| result.field210_ = value; | |
| return this; | |
| } | |
| public Builder ClearField210() { | |
| result.hasField210 = false; | |
| result.field210_ = 0; | |
| return this; | |
| } | |
| public bool HasField211 { | |
| get { return result.HasField211; } | |
| } | |
| public int Field211 { | |
| get { return result.Field211; } | |
| set { SetField211(value); } | |
| } | |
| public Builder SetField211(int value) { | |
| result.hasField211 = true; | |
| result.field211_ = value; | |
| return this; | |
| } | |
| public Builder ClearField211() { | |
| result.hasField211 = false; | |
| result.field211_ = 0; | |
| return this; | |
| } | |
| public bool HasField212 { | |
| get { return result.HasField212; } | |
| } | |
| public int Field212 { | |
| get { return result.Field212; } | |
| set { SetField212(value); } | |
| } | |
| public Builder SetField212(int value) { | |
| result.hasField212 = true; | |
| result.field212_ = value; | |
| return this; | |
| } | |
| public Builder ClearField212() { | |
| result.hasField212 = false; | |
| result.field212_ = 0; | |
| return this; | |
| } | |
| public bool HasField213 { | |
| get { return result.HasField213; } | |
| } | |
| public int Field213 { | |
| get { return result.Field213; } | |
| set { SetField213(value); } | |
| } | |
| public Builder SetField213(int value) { | |
| result.hasField213 = true; | |
| result.field213_ = value; | |
| return this; | |
| } | |
| public Builder ClearField213() { | |
| result.hasField213 = false; | |
| result.field213_ = 0; | |
| return this; | |
| } | |
| public bool HasField216 { | |
| get { return result.HasField216; } | |
| } | |
| public int Field216 { | |
| get { return result.Field216; } | |
| set { SetField216(value); } | |
| } | |
| public Builder SetField216(int value) { | |
| result.hasField216 = true; | |
| result.field216_ = value; | |
| return this; | |
| } | |
| public Builder ClearField216() { | |
| result.hasField216 = false; | |
| result.field216_ = 0; | |
| return this; | |
| } | |
| public bool HasField217 { | |
| get { return result.HasField217; } | |
| } | |
| public int Field217 { | |
| get { return result.Field217; } | |
| set { SetField217(value); } | |
| } | |
| public Builder SetField217(int value) { | |
| result.hasField217 = true; | |
| result.field217_ = value; | |
| return this; | |
| } | |
| public Builder ClearField217() { | |
| result.hasField217 = false; | |
| result.field217_ = 0; | |
| return this; | |
| } | |
| public bool HasField218 { | |
| get { return result.HasField218; } | |
| } | |
| public int Field218 { | |
| get { return result.Field218; } | |
| set { SetField218(value); } | |
| } | |
| public Builder SetField218(int value) { | |
| result.hasField218 = true; | |
| result.field218_ = value; | |
| return this; | |
| } | |
| public Builder ClearField218() { | |
| result.hasField218 = false; | |
| result.field218_ = 0; | |
| return this; | |
| } | |
| public bool HasField220 { | |
| get { return result.HasField220; } | |
| } | |
| public int Field220 { | |
| get { return result.Field220; } | |
| set { SetField220(value); } | |
| } | |
| public Builder SetField220(int value) { | |
| result.hasField220 = true; | |
| result.field220_ = value; | |
| return this; | |
| } | |
| public Builder ClearField220() { | |
| result.hasField220 = false; | |
| result.field220_ = 0; | |
| return this; | |
| } | |
| public bool HasField221 { | |
| get { return result.HasField221; } | |
| } | |
| public int Field221 { | |
| get { return result.Field221; } | |
| set { SetField221(value); } | |
| } | |
| public Builder SetField221(int value) { | |
| result.hasField221 = true; | |
| result.field221_ = value; | |
| return this; | |
| } | |
| public Builder ClearField221() { | |
| result.hasField221 = false; | |
| result.field221_ = 0; | |
| return this; | |
| } | |
| public bool HasField222 { | |
| get { return result.HasField222; } | |
| } | |
| public float Field222 { | |
| get { return result.Field222; } | |
| set { SetField222(value); } | |
| } | |
| public Builder SetField222(float value) { | |
| result.hasField222 = true; | |
| result.field222_ = value; | |
| return this; | |
| } | |
| public Builder ClearField222() { | |
| result.hasField222 = false; | |
| result.field222_ = 0F; | |
| return this; | |
| } | |
| public bool HasField63 { | |
| get { return result.HasField63; } | |
| } | |
| public int Field63 { | |
| get { return result.Field63; } | |
| set { SetField63(value); } | |
| } | |
| public Builder SetField63(int value) { | |
| result.hasField63 = true; | |
| result.field63_ = value; | |
| return this; | |
| } | |
| public Builder ClearField63() { | |
| result.hasField63 = false; | |
| result.field63_ = 0; | |
| return this; | |
| } | |
| public pbc::IPopsicleList<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1> Group1List { | |
| get { return result.group1_; } | |
| } | |
| public int Group1Count { | |
| get { return result.Group1Count; } | |
| } | |
| public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 GetGroup1(int index) { | |
| return result.GetGroup1(index); | |
| } | |
| public Builder SetGroup1(int index, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.group1_[index] = value; | |
| return this; | |
| } | |
| public Builder SetGroup1(int index, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder builderForValue) { | |
| pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | |
| result.group1_[index] = builderForValue.Build(); | |
| return this; | |
| } | |
| public Builder AddGroup1(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.group1_.Add(value); | |
| return this; | |
| } | |
| public Builder AddGroup1(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder builderForValue) { | |
| pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue"); | |
| result.group1_.Add(builderForValue.Build()); | |
| return this; | |
| } | |
| public Builder AddRangeGroup1(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1> values) { | |
| base.AddRange(values, result.group1_); | |
| return this; | |
| } | |
| public Builder ClearGroup1() { | |
| result.group1_.Clear(); | |
| return this; | |
| } | |
| public pbc::IPopsicleList<string> Field128List { | |
| get { return result.field128_; } | |
| } | |
| public int Field128Count { | |
| get { return result.Field128Count; } | |
| } | |
| public string GetField128(int index) { | |
| return result.GetField128(index); | |
| } | |
| public Builder SetField128(int index, string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.field128_[index] = value; | |
| return this; | |
| } | |
| public Builder AddField128(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.field128_.Add(value); | |
| return this; | |
| } | |
| public Builder AddRangeField128(scg::IEnumerable<string> values) { | |
| base.AddRange(values, result.field128_); | |
| return this; | |
| } | |
| public Builder ClearField128() { | |
| result.field128_.Clear(); | |
| return this; | |
| } | |
| public bool HasField131 { | |
| get { return result.HasField131; } | |
| } | |
| public long Field131 { | |
| get { return result.Field131; } | |
| set { SetField131(value); } | |
| } | |
| public Builder SetField131(long value) { | |
| result.hasField131 = true; | |
| result.field131_ = value; | |
| return this; | |
| } | |
| public Builder ClearField131() { | |
| result.hasField131 = false; | |
| result.field131_ = 0L; | |
| return this; | |
| } | |
| public pbc::IPopsicleList<string> Field127List { | |
| get { return result.field127_; } | |
| } | |
| public int Field127Count { | |
| get { return result.Field127Count; } | |
| } | |
| public string GetField127(int index) { | |
| return result.GetField127(index); | |
| } | |
| public Builder SetField127(int index, string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.field127_[index] = value; | |
| return this; | |
| } | |
| public Builder AddField127(string value) { | |
| pb::ThrowHelper.ThrowIfNull(value, "value"); | |
| result.field127_.Add(value); | |
| return this; | |
| } | |
| public Builder AddRangeField127(scg::IEnumerable<string> values) { | |
| base.AddRange(values, result.field127_); | |
| return this; | |
| } | |
| public Builder ClearField127() { | |
| result.field127_.Clear(); | |
| return this; | |
| } | |
| public bool HasField129 { | |
| get { return result.HasField129; } | |
| } | |
| public int Field129 { | |
| get { return result.Field129; } | |
| set { SetField129(value); } | |
| } | |
| public Builder SetField129(int value) { | |
| result.hasField129 = true; | |
| result.field129_ = value; | |
| return this; | |
| } | |
| public Builder ClearField129() { | |
| result.hasField129 = false; | |
| result.field129_ = 0; | |
| return this; | |
| } | |
| public pbc::IPopsicleList<long> Field130List { | |
| get { return result.field130_; } | |
| } | |
| public int Field130Count { | |
| get { return result.Field130Count; } | |
| } | |
| public long GetField130(int index) { | |
| return result.GetField130(index); | |
| } | |
| public Builder SetField130(int index, long value) { | |
| result.field130_[index] = value; | |
| return this; | |
| } | |
| public Builder AddField130(long value) { | |
| result.field130_.Add(value); | |
| return this; | |
| } | |
| public Builder AddRangeField130(scg::IEnumerable<long> values) { | |
| base.AddRange(values, result.field130_); | |
| return this; | |
| } | |
| public Builder ClearField130() { | |
| result.field130_.Clear(); | |
| return this; | |
| } | |
| public bool HasField205 { | |
| get { return result.HasField205; } | |
| } | |
| public bool Field205 { | |
| get { return result.Field205; } | |
| set { SetField205(value); } | |
| } | |
| public Builder SetField205(bool value) { | |
| result.hasField205 = true; | |
| result.field205_ = value; | |
| return this; | |
| } | |
| public Builder ClearField205() { | |
| result.hasField205 = false; | |
| result.field205_ = false; | |
| return this; | |
| } | |
| public bool HasField206 { | |
| get { return result.HasField206; } | |
| } | |
| public bool Field206 { | |
| get { return result.Field206; } | |
| set { SetField206(value); } | |
| } | |
| public Builder SetField206(bool value) { | |
| result.hasField206 = true; | |
| result.field206_ = value; | |
| return this; | |
| } | |
| public Builder ClearField206() { | |
| result.hasField206 = false; | |
| result.field206_ = false; | |
| return this; | |
| } | |
| } | |
| static SpeedMessage2() { | |
| object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null); | |
| } | |
| } | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class SpeedMessage2GroupedMessage : pb::GeneratedMessage<SpeedMessage2GroupedMessage, SpeedMessage2GroupedMessage.Builder> { | |
| private static readonly SpeedMessage2GroupedMessage defaultInstance = new Builder().BuildPartial(); | |
| public static SpeedMessage2GroupedMessage DefaultInstance { | |
| get { return defaultInstance; } | |
| } | |
| public override SpeedMessage2GroupedMessage DefaultInstanceForType { | |
| get { return defaultInstance; } | |
| } | |
| protected override SpeedMessage2GroupedMessage ThisMessage { | |
| get { return this; } | |
| } | |
| public static pbd::MessageDescriptor Descriptor { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage2GroupedMessage__Descriptor; } | |
| } | |
| protected override pb::FieldAccess.FieldAccessorTable<SpeedMessage2GroupedMessage, SpeedMessage2GroupedMessage.Builder> InternalFieldAccessors { | |
| get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_benchmarks_SpeedMessage2GroupedMessage__FieldAccessorTable; } | |
| } | |
| public const int Field1FieldNumber = 1; | |
| private bool hasField1; | |
| private float field1_ = 0F; | |
| public bool HasField1 { | |
| get { return hasField1; } | |
| } | |
| public float Field1 { | |
| get { return field1_; } | |
| } | |
| public const int Field2FieldNumber = 2; | |
| private bool hasField2; | |
| private float field2_ = 0F; | |
| public bool HasField2 { | |
| get { return hasField2; } | |
| } | |
| public float Field2 { | |
| get { return field2_; } | |
| } | |
| public const int Field3FieldNumber = 3; | |
| private bool hasField3; | |
| private float field3_ = 0F; | |
| public bool HasField3 { | |
| get { return hasField3; } | |
| } | |
| public float Field3 { | |
| get { return field3_; } | |
| } | |
| public const int Field4FieldNumber = 4; | |
| private bool hasField4; | |
| private bool field4_ = false; | |
| public bool HasField4 { | |
| get { return hasField4; } | |
| } | |
| public bool Field4 { | |
| get { return field4_; } | |
| } | |
| public const int Field5FieldNumber = 5; | |
| private bool hasField5; | |
| private bool field5_ = false; | |
| public bool HasField5 { | |
| get { return hasField5; } | |
| } | |
| public bool Field5 { | |
| get { return field5_; } | |
| } | |
| public const int Field6FieldNumber = 6; | |
| private bool hasField6; | |
| private bool field6_ = true; | |
| public bool HasField6 { | |
| get { return hasField6; } | |
| } | |
| public bool Field6 { | |
| get { return field6_; } | |
| } | |
| public const int Field7FieldNumber = 7; | |
| private bool hasField7; | |
| private bool field7_ = false; | |
| public bool HasField7 { | |
| get { return hasField7; } | |
| } | |
| public bool Field7 { | |
| get { return field7_; } | |
| } | |
| public const int Field8FieldNumber = 8; | |
| private bool hasField8; | |
| private float field8_ = 0F; | |
| public bool HasField8 { | |
| get { return hasField8; } | |
| } | |
| public float Field8 { | |
| get { return field8_; } | |
| } | |
| public const int Field9FieldNumber = 9; | |
| private bool hasField9; | |
| private bool field9_ = false; | |
| public bool HasField9 { | |
| get { return hasField9; } | |
| } | |
| public bool Field9 { | |
| get { return field9_; } | |
| } | |
| public const int Field10FieldNumber = 10; | |
| private bool hasField10; | |
| private float field10_ = 0F; | |
| public bool HasField10 { | |
| get { return hasField10; } | |
| } | |
| public float Field10 { | |
| get { return field10_; } | |
| } | |
| public const int Field11FieldNumber = 11; | |
| private bool hasField11; | |
| private long field11_ = 0L; | |
| public bool HasField11 { | |
| get { return hasField11; } | |
| } | |
| public long Field11 { | |
| get { return field11_; } | |
| } | |
| public override bool IsInitialized { | |
| get { | |
| return true; | |
| } | |
| } | |
| public override void WriteTo(pb::CodedOutputStream output) { | |
| int size = SerializedSize; | |
| if (HasField1) { | |
| output.WriteFloat(1, "field1", Field1); | |
| } | |
| if (HasField2) { | |
| output.WriteFloat(2, "field2", Field2); | |
| } | |
| if (HasField3) { | |
| output.WriteFloat(3, "field3", Field3); | |
| } | |
| if (HasField4) { | |
| output.WriteBool(4, "field4", Field4); | |
| } | |
| if (HasField5) { | |
| output.WriteBool(5, "field5", Field5); | |
| } | |
| if (HasField6) { | |
| output.WriteBool(6, "field6", Field6); | |
| } | |
| if (HasField7) { | |
| output.WriteBool(7, "field7", Field7); | |
| } | |
| if (HasField8) { | |
| output.WriteFloat(8, "field8", Field8); | |
| } | |
| if (HasField9) { | |
| output.WriteBool(9, "field9", Field9); | |
| } | |
| if (HasField10) { | |
| output.WriteFloat(10, "field10", Field10); | |
| } | |
| if (HasField11) { | |
| output.WriteInt64(11, "field11", Field11); | |
| } | |
| UnknownFields.WriteTo(output); | |
| } | |
| private int memoizedSerializedSize = -1; | |
| public override int SerializedSize { | |
| get { | |
| int size = memoizedSerializedSize; | |
| if (size != -1) return size; | |
| size = 0; | |
| if (HasField1) { | |
| size += pb::CodedOutputStream.ComputeFloatSize(1, Field1); | |
| } | |
| if (HasField2) { | |
| size += pb::CodedOutputStream.ComputeFloatSize(2, Field2); | |
| } | |
| if (HasField3) { | |
| size += pb::CodedOutputStream.ComputeFloatSize(3, Field3); | |
| } | |
| if (HasField4) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(4, Field4); | |
| } | |
| if (HasField5) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(5, Field5); | |
| } | |
| if (HasField6) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(6, Field6); | |
| } | |
| if (HasField7) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(7, Field7); | |
| } | |
| if (HasField8) { | |
| size += pb::CodedOutputStream.ComputeFloatSize(8, Field8); | |
| } | |
| if (HasField9) { | |
| size += pb::CodedOutputStream.ComputeBoolSize(9, Field9); | |
| } | |
| if (HasField10) { | |
| size += pb::CodedOutputStream.ComputeFloatSize(10, Field10); | |
| } | |
| if (HasField11) { | |
| size += pb::CodedOutputStream.ComputeInt64Size(11, Field11); | |
| } | |
| size += UnknownFields.SerializedSize; | |
| memoizedSerializedSize = size; | |
| return size; | |
| } | |
| } | |
| public static SpeedMessage2GroupedMessage ParseFrom(pb::ByteString data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static SpeedMessage2GroupedMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage2GroupedMessage ParseFrom(byte[] data) { | |
| return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); | |
| } | |
| public static SpeedMessage2GroupedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage2GroupedMessage ParseFrom(global::System.IO.Stream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static SpeedMessage2GroupedMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static SpeedMessage2GroupedMessage ParseDelimitedFrom(global::System.IO.Stream input) { | |
| return CreateBuilder().MergeDelimitedFrom(input).BuildParsed(); | |
| } | |
| public static SpeedMessage2GroupedMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { | |
| return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed(); | |
| } | |
| public static SpeedMessage2GroupedMessage ParseFrom(pb::CodedInputStream input) { | |
| return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); | |
| } | |
| public static SpeedMessage2GroupedMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); | |
| } | |
| public static Builder CreateBuilder() { return new Builder(); } | |
| public override Builder ToBuilder() { return CreateBuilder(this); } | |
| public override Builder CreateBuilderForType() { return new Builder(); } | |
| public static Builder CreateBuilder(SpeedMessage2GroupedMessage prototype) { | |
| return (Builder) new Builder().MergeFrom(prototype); | |
| } | |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] | |
| [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] | |
| [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")] | |
| public sealed partial class Builder : pb::GeneratedBuilder<SpeedMessage2GroupedMessage, Builder> { | |
| protected override Builder ThisBuilder { | |
| get { return this; } | |
| } | |
| public Builder() {} | |
| SpeedMessage2GroupedMessage result = new SpeedMessage2GroupedMessage(); | |
| protected override SpeedMessage2GroupedMessage MessageBeingBuilt { | |
| get { return result; } | |
| } | |
| public override Builder Clear() { | |
| result = new SpeedMessage2GroupedMessage(); | |
| return this; | |
| } | |
| public override Builder Clone() { | |
| return new Builder().MergeFrom(result); | |
| } | |
| public override pbd::MessageDescriptor DescriptorForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Descriptor; } | |
| } | |
| public override SpeedMessage2GroupedMessage DefaultInstanceForType { | |
| get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance; } | |
| } | |
| public override SpeedMessage2GroupedMessage BuildPartial() { | |
| if (result == null) { | |
| throw new global::System.InvalidOperationException("build() has already been called on this Builder"); | |
| } | |
| SpeedMessage2GroupedMessage returnMe = result; | |
| result = null; | |
| return returnMe; | |
| } | |
| public override Builder MergeFrom(pb::IMessage other) { | |
| if (other is SpeedMessage2GroupedMessage) { | |
| return MergeFrom((SpeedMessage2GroupedMessage) other); | |
| } else { | |
| base.MergeFrom(other); | |
| return this; | |
| } | |
| } | |
| public override Builder MergeFrom(SpeedMessage2GroupedMessage other) { | |
| if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance) return this; | |
| if (other.HasField1) { | |
| Field1 = other.Field1; | |
| } | |
| if (other.HasField2) { | |
| Field2 = other.Field2; | |
| } | |
| if (other.HasField3) { | |
| Field3 = other.Field3; | |
| } | |
| if (other.HasField4) { | |
| Field4 = other.Field4; | |
| } | |
| if (other.HasField5) { | |
| Field5 = other.Field5; | |
| } | |
| if (other.HasField6) { | |
| Field6 = other.Field6; | |
| } | |
| if (other.HasField7) { | |
| Field7 = other.Field7; | |
| } | |
| if (other.HasField8) { | |
| Field8 = other.Field8; | |
| } | |
| if (other.HasField9) { | |
| Field9 = other.Field9; | |
| } | |
| if (other.HasField10) { | |
| Field10 = other.Field10; | |
| } | |
| if (other.HasField11) { | |
| Field11 = other.Field11; | |
| } | |
| this.MergeUnknownFields(other.UnknownFields); | |
| return this; | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input) { | |
| return MergeFrom(input, pb::ExtensionRegistry.Empty); | |
| } | |
| public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { | |
| pb::UnknownFieldSet.Builder unknownFields = null; | |
| while (true) { | |
| uint tag = input.ReadTag(); | |
| switch (tag) { | |
| case 0: { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| default: { | |
| if (pb::WireFormat.IsEndGroupTag(tag)) { | |
| if (unknownFields != null) { | |
| this.UnknownFields = unknownFields.Build(); | |
| } | |
| return this; | |
| } | |
| if (unknownFields == null) { | |
| unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); | |
| } | |
| ParseUnknownField(input, unknownFields, extensionRegistry, tag); | |
| break; | |
| } | |
| case 13: { | |
| Field1 = input.ReadFloat(); | |
| break; | |
| } | |
| case 21: { | |
| Field2 = input.ReadFloat(); | |
| break; | |
| } | |
| case 29: { | |
| Field3 = input.ReadFloat(); | |
| break; | |
| } | |
| case 32: { | |
| Field4 = input.ReadBool(); | |
| break; | |
| } | |
| case 40: { | |
| Field5 = input.ReadBool(); | |
| break; | |
| } | |
| case 48: { | |
| Field6 = input.ReadBool(); | |
| break; | |
| } | |
| case 56: { | |
| Field7 = input.ReadBool(); | |
| break; | |
| } | |
| case 69: { | |
| Field8 = input.ReadFloat(); | |
| break; | |
| } | |
| case 72: { | |
| Field9 = input.ReadBool(); | |
| break; | |
| } | |
| case 85: { | |
| Field10 = input.ReadFloat(); | |
| break; | |
| } | |
| case 88: { | |
| Field11 = input.ReadInt64(); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| public bool HasField1 { | |
| get { return result.HasField1; } | |
| } | |
| public float Field1 { | |
| get { return result.Field1; } | |
| set { SetField1(value); } | |
| } | |
| public Builder SetField1(float value) { | |
| result.hasField1 = true; | |
| result.field1_ = value; | |
| return this; | |
| } | |
| public Builder ClearField1() { | |
| result.hasField1 = false; | |
| result.field1_ = 0F; | |
| return this; | |
| } | |
| public bool HasField2 { | |
| get { return result.HasField2; } | |
| } | |
| public float Field2 { | |
| get { return result.Field2; } | |
| set { SetField2(value); } | |
| } | |
| public Builder SetField2(float value) { | |
| result.hasField2 = true; | |
| result.field2_ = value; | |
| return this; | |
| } | |
| public Builder ClearField2() { | |
| result.hasField2 = false; | |
| result.field2_ = 0F; | |
| return this; | |
| } | |
| public bool HasField3 { | |
| get { return result.HasField3; } | |
| } | |
| public float Field3 { | |
| get { return result.Field3; } | |
| set { SetField3(value); } | |
| } | |
| public Builder SetField3(float value) { | |
| result.hasField3 = true; | |
| result.field3_ = value; | |
| return this; | |
| } | |
| public Builder ClearField3() { | |
| result.hasField3 = false; | |
| result.field3_ = 0F; | |
| return this; | |
| } | |
| public bool HasField4 { | |
| get { return result.HasField4; } | |
| } | |
| public bool Field4 { | |
| get { return result.Field4; } | |
| set { SetField4(value); } | |
| } | |
| public Builder SetField4(bool value) { | |
| result.hasField4 = true; | |
| result.field4_ = value; | |
| return this; | |
| } | |
| public Builder ClearField4() { | |
| result.hasField4 = false; | |
| result.field4_ = false; | |
| return this; | |
| } | |
| public bool HasField5 { | |
| get { return result.HasField5; } | |
| } | |
| public bool Field5 { | |
| get { return result.Field5; } | |
| set { SetField5(value); } | |
| } | |
| public Builder SetField5(bool value) { | |
| result.hasField5 = true; | |
| result.field5_ = value; | |
| return this; | |
| } | |
| public Builder ClearField5() { | |
| result.hasField5 = false; | |
| result.field5_ = false; | |
| return this; | |
| } | |
| public bool HasField6 { | |
| get { return result.HasField6; } | |
| } | |
| public bool Field6 { | |
| get { return result.Field6; } | |
| set { SetField6(value); } | |
| } | |
| public Builder SetField6(bool value) { | |
| result.hasField6 = true; | |
| result.field6_ = value; | |
| return this; | |
| } | |
| public Builder ClearField6() { | |
| result.hasField6 = false; | |
| result.field6_ = true; | |
| return this; | |
| } | |
| public bool HasField7 { | |
| get { return result.HasField7; } | |
| } | |
| public bool Field7 { | |
| get { return result.Field7; } | |
| set { SetField7(value); } | |
| } | |
| public Builder SetField7(bool value) { | |
| result.hasField7 = true; | |
| result.field7_ = value; | |
| return this; | |
| } | |
| public Builder ClearField7() { | |
| result.hasField7 = false; | |
| result.field7_ = false; | |
| return this; | |
| } | |
| public bool HasField8 { | |
| get { return result.HasField8; } | |
| } | |
| public float Field8 { | |
| get { return result.Field8; } | |
| set { SetField8(value); } | |
| } | |
| public Builder SetField8(float value) { | |
| result.hasField8 = true; | |
| result.field8_ = value; | |
| return this; | |
| } | |
| public Builder ClearField8() { | |
| result.hasField8 = false; | |
| result.field8_ = 0F; | |
| return this; | |
| } | |
| public bool HasField9 { | |
| get { return result.HasField9; } | |
| } | |
| public bool Field9 { | |
| get { return result.Field9; } | |
| set { SetField9(value); } | |
| } | |
| public Builder SetField9(bool value) { | |
| result.hasField9 = true; | |
| result.field9_ = value; | |
| return this; | |
| } | |
| public Builder ClearField9() { | |
| result.hasField9 = false; | |
| result.field9_ = false; | |
| return this; | |
| } | |
| public bool HasField10 { | |
| get { return result.HasField10; } | |
| } | |
| public float Field10 { | |
| get { return result.Field10; } | |
| set { SetField10(value); } | |
| } | |
| public Builder SetField10(float value) { | |
| result.hasField10 = true; | |
| result.field10_ = value; | |
| return this; | |
| } | |
| public Builder ClearField10() { | |
| result.hasField10 = false; | |
| result.field10_ = 0F; | |
| return this; | |
| } | |
| public bool HasField11 { | |
| get { return result.HasField11; } | |
| } | |
| public long Field11 { | |
| get { return result.Field11; } | |
| set { SetField11(value); } | |
| } | |
| public Builder SetField11(long value) { | |
| result.hasField11 = true; | |
| result.field11_ = value; | |
| return this; | |
| } | |
| public Builder ClearField11() { | |
| result.hasField11 = false; | |
| result.field11_ = 0L; | |
| return this; | |
| } | |
| } | |
| static SpeedMessage2GroupedMessage() { | |
| object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null); | |
| } | |
| } | |
| #endregion | |
| } |