diff --git a/.gitignore b/.gitignore index 54ed9562f4..0127b4aa42 100644 --- a/.gitignore +++ b/.gitignore @@ -6,10 +6,16 @@ src/ProtocolBuffers/bin/ src/ProtocolBuffers/obj/ src/ProtocolBuffers.Test/bin/ src/ProtocolBuffers.Test/obj/ +src/ProtoBench/bin/ +src/ProtoBench/obj/ +src/ProtoDump/bin/ +src/ProtoDump/obj/ src/ProtoGen/bin/ src/ProtoGen/obj/ src/ProtoGen.Test/bin/ src/ProtoGen.Test/obj/ +src/ProtoMunge/bin/ +src/ProtoMunge/obj/ tmp/ dist/ *.user diff --git a/ProtocolBuffers.build b/ProtocolBuffers.build index 97ff2c5d92..23cd6b4042 100644 --- a/ProtocolBuffers.build +++ b/ProtocolBuffers.build @@ -72,6 +72,7 @@ workingdir="${tmp-dir}"> + @@ -114,6 +115,12 @@ + + + + + + + + + diff --git a/protos/google/protobuf/benchmark.proto b/protos/google/protobuf/benchmark.proto new file mode 100644 index 0000000000..2dbcdc897c --- /dev/null +++ b/protos/google/protobuf/benchmark.proto @@ -0,0 +1,140 @@ +import "google/protobuf/csharp_options.proto"; +import "google/protobuf/descriptor.proto"; +option (google.protobuf.csharp_file_options).namespace = "Google.ProtocolBuffers.BenchmarkProtos"; +option (google.protobuf.csharp_file_options).umbrella_classname = "BenchmarkProtoFile"; + +package proto2.benchmark.v2_api; + +option optimize_for = SPEED; + +message Message1 { + required string field1 = 1; + optional string field9 = 9; + optional string field18 = 18; + optional bool field80 = 80 [default=false]; + optional bool field81 = 81 [default=true]; + required int32 field2 = 2; + required int32 field3 = 3; + optional int32 field280 = 280; + optional int32 field6 = 6 [default=0]; + optional int64 field22 = 22; + optional string field4 = 4; + repeated fixed64 field5 = 5; + optional bool field59 = 59 [default=false]; + optional string field7 = 7; + optional int32 field16 = 16; + optional int32 field130 = 130 [default=0]; + optional bool field12 = 12 [default=true]; + optional bool field17 = 17 [default=true]; + optional bool field13 = 13 [default=true]; + optional bool field14 = 14 [default=true]; + optional int32 field104 = 104 [default=0]; + optional int32 field100 = 100 [default=0]; + optional int32 field101 = 101 [default=0]; + optional string field102 = 102; + optional string field103 = 103; + optional int32 field29 = 29 [default=0]; + optional bool field30 = 30 [default=false]; + optional int32 field60 = 60 [default=-1]; + optional int32 field271 = 271 [default=-1]; + optional int32 field272 = 272 [default=-1]; + optional int32 field150 = 150; + optional int32 field23 = 23 [default=0]; + optional bool field24 = 24 [default=false]; + optional int32 field25 = 25 [default=0]; + optional Message2 field15 = 15; + optional bool field78 = 78; + optional int32 field67 = 67 [default=0]; + optional int32 field68 = 68; + optional int32 field128 = 128 [default=0]; + optional string field129 = 129 [default="xxxxxxxxxxxxxxxxxxxxx"]; + optional int32 field131 = 131 [default=0]; +} + +message Message2 { + optional int32 field1 = 1 [default=0]; + optional int32 field2 = 2 [default=0]; + optional int32 field3 = 3 [default=0]; + optional string field15 = 15; + optional bool field12 = 12 [default=true]; + optional int64 field13 = 13; + optional int64 field14 = 14; + optional int32 field16 = 16; + optional int32 field19 = 19 [default=2]; + optional bool field20 = 20 [default=true]; + optional bool field28 = 28 [default=true]; + optional fixed64 field21 = 21; + optional int32 field22 = 22; + optional bool field23 = 23 [ default=false ]; + optional bool field206 = 206 [default=false]; + optional fixed32 field203 = 203; + optional int32 field204 = 204; + optional string field205 = 205; + optional uint64 field207 = 207; + optional uint64 field300 = 300; +} + +message Message3 { + optional string field1 = 1; + optional int64 field3 = 3; + optional int64 field4 = 4; + optional int64 field30 = 30; + optional bool field75 = 75 [default=false]; + optional string field6 = 6; + optional bytes field2 = 2; + optional int32 field21 = 21 [default=0]; + optional int32 field71 = 71; + optional float field25 = 25; + optional int32 field109 = 109 [default=0]; + optional int32 field210 = 210 [default=0]; + optional int32 field211 = 211 [default=0]; + optional int32 field212 = 212 [default=0]; + optional int32 field213 = 213 [default=0]; + optional int32 field216 = 216 [default=0]; + optional int32 field217 = 217 [default=0]; + optional int32 field218 = 218 [default=0]; + optional int32 field220 = 220 [default=0]; + optional int32 field221 = 221 [default=0]; + optional float field222 = 222 [default=0.0]; + optional int32 field63 = 63; + + repeated group Group1 = 10 { + required float field11 = 11; + optional float field26 = 26; + optional string field12 = 12; + optional string field13 = 13; + repeated string field14 = 14; + required uint64 field15 = 15; + optional int32 field5 = 5; + optional string field27 = 27; + optional int32 field28 = 28; + optional string field29 = 29; + optional string field16 = 16; + repeated string field22 = 22; + repeated int32 field73 = 73; + optional int32 field20 = 20 [default=0]; + optional string field24 = 24; + optional Message4 field31 = 31; + } + repeated string field128 = 128; + optional int64 field131 = 131; + repeated string field127 = 127; + optional int32 field129 = 129; + repeated int64 field130 = 130; + optional bool field205 = 205 [default=false]; + optional bool field206 = 206 [default=false]; +} + +message Message4 { + optional float field1 = 1; + optional float field2 = 2; + optional float field3 = 3 [default=0.0]; + optional bool field4 = 4; + optional bool field5 = 5; + optional bool field6 = 6 [default=true]; + optional bool field7 = 7 [default=false]; + optional float field8 = 8; + optional bool field9 = 9; + optional float field10 = 10; + optional int64 field11 = 11; +} diff --git a/src/ProtoBench/BenchmarkProtoFile.cs b/src/ProtoBench/BenchmarkProtoFile.cs new file mode 100644 index 0000000000..2301603fd1 --- /dev/null +++ b/src/ProtoBench/BenchmarkProtoFile.cs @@ -0,0 +1,5742 @@ +// Generated by the protocol buffer compiler. 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.BenchmarkProtos { + + public static partial class BenchmarkProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "Ch9nb29nbGUvcHJvdG9idWYvYmVuY2htYXJrLnByb3RvEhdwcm90bzIuYmVu" + + "Y2htYXJrLnYyX2FwaRokZ29vZ2xlL3Byb3RvYnVmL2NzaGFycF9vcHRpb25z" + + "LnByb3RvGiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90byLxBgoI" + + "TWVzc2FnZTESDgoGZmllbGQxGAEgAigJEg4KBmZpZWxkORgJIAEoCRIPCgdm" + + "aWVsZDE4GBIgASgJEhYKB2ZpZWxkODAYUCABKAg6BWZhbHNlEhUKB2ZpZWxk" + + "ODEYUSABKAg6BHRydWUSDgoGZmllbGQyGAIgAigFEg4KBmZpZWxkMxgDIAIo" + + "BRIRCghmaWVsZDI4MBiYAiABKAUSEQoGZmllbGQ2GAYgASgFOgEwEg8KB2Zp" + + "ZWxkMjIYFiABKAMSDgoGZmllbGQ0GAQgASgJEg4KBmZpZWxkNRgFIAMoBhIW" + + "CgdmaWVsZDU5GDsgASgIOgVmYWxzZRIOCgZmaWVsZDcYByABKAkSDwoHZmll" + + "bGQxNhgQIAEoBRIUCghmaWVsZDEzMBiCASABKAU6ATASFQoHZmllbGQxMhgM" + + "IAEoCDoEdHJ1ZRIVCgdmaWVsZDE3GBEgASgIOgR0cnVlEhUKB2ZpZWxkMTMY" + + "DSABKAg6BHRydWUSFQoHZmllbGQxNBgOIAEoCDoEdHJ1ZRITCghmaWVsZDEw" + + "NBhoIAEoBToBMBITCghmaWVsZDEwMBhkIAEoBToBMBITCghmaWVsZDEwMRhl" + + "IAEoBToBMBIQCghmaWVsZDEwMhhmIAEoCRIQCghmaWVsZDEwMxhnIAEoCRIS" + + "CgdmaWVsZDI5GB0gASgFOgEwEhYKB2ZpZWxkMzAYHiABKAg6BWZhbHNlEhMK" + + "B2ZpZWxkNjAYPCABKAU6Ai0xEhUKCGZpZWxkMjcxGI8CIAEoBToCLTESFQoI" + + "ZmllbGQyNzIYkAIgASgFOgItMRIRCghmaWVsZDE1MBiWASABKAUSEgoHZmll" + + "bGQyMxgXIAEoBToBMBIWCgdmaWVsZDI0GBggASgIOgVmYWxzZRISCgdmaWVs" + + "ZDI1GBkgASgFOgEwEjIKB2ZpZWxkMTUYDyABKAsyIS5wcm90bzIuYmVuY2ht" + + "YXJrLnYyX2FwaS5NZXNzYWdlMhIPCgdmaWVsZDc4GE4gASgIEhIKB2ZpZWxk" + + "NjcYQyABKAU6ATASDwoHZmllbGQ2OBhEIAEoBRIUCghmaWVsZDEyOBiAASAB" + + "KAU6ATASKAoIZmllbGQxMjkYgQEgASgJOhV4eHh4eHh4eHh4eHh4eHh4eHh4" + + "eHgSFAoIZmllbGQxMzEYgwEgASgFOgEwIpMDCghNZXNzYWdlMhIRCgZmaWVs" + + "ZDEYASABKAU6ATASEQoGZmllbGQyGAIgASgFOgEwEhEKBmZpZWxkMxgDIAEo" + + "BToBMBIPCgdmaWVsZDE1GA8gASgJEhUKB2ZpZWxkMTIYDCABKAg6BHRydWUS" + + "DwoHZmllbGQxMxgNIAEoAxIPCgdmaWVsZDE0GA4gASgDEg8KB2ZpZWxkMTYY" + + "ECABKAUSEgoHZmllbGQxORgTIAEoBToBMhIVCgdmaWVsZDIwGBQgASgIOgR0" + + "cnVlEhUKB2ZpZWxkMjgYHCABKAg6BHRydWUSDwoHZmllbGQyMRgVIAEoBhIP" + + "CgdmaWVsZDIyGBYgASgFEhYKB2ZpZWxkMjMYFyABKAg6BWZhbHNlEhgKCGZp" + + "ZWxkMjA2GM4BIAEoCDoFZmFsc2USEQoIZmllbGQyMDMYywEgASgHEhEKCGZp" + + "ZWxkMjA0GMwBIAEoBRIRCghmaWVsZDIwNRjNASABKAkSEQoIZmllbGQyMDcY" + + "zwEgASgEEhEKCGZpZWxkMzAwGKwCIAEoBCLHBwoITWVzc2FnZTMSDgoGZmll" + + "bGQxGAEgASgJEg4KBmZpZWxkMxgDIAEoAxIOCgZmaWVsZDQYBCABKAMSDwoH" + + "ZmllbGQzMBgeIAEoAxIWCgdmaWVsZDc1GEsgASgIOgVmYWxzZRIOCgZmaWVs" + + "ZDYYBiABKAkSDgoGZmllbGQyGAIgASgMEhIKB2ZpZWxkMjEYFSABKAU6ATAS" + + "DwoHZmllbGQ3MRhHIAEoBRIPCgdmaWVsZDI1GBkgASgCEhMKCGZpZWxkMTA5" + + "GG0gASgFOgEwEhQKCGZpZWxkMjEwGNIBIAEoBToBMBIUCghmaWVsZDIxMRjT" + + "ASABKAU6ATASFAoIZmllbGQyMTIY1AEgASgFOgEwEhQKCGZpZWxkMjEzGNUB" + + "IAEoBToBMBIUCghmaWVsZDIxNhjYASABKAU6ATASFAoIZmllbGQyMTcY2QEg" + + "ASgFOgEwEhQKCGZpZWxkMjE4GNoBIAEoBToBMBIUCghmaWVsZDIyMBjcASAB" + + "KAU6ATASFAoIZmllbGQyMjEY3QEgASgFOgEwEhQKCGZpZWxkMjIyGN4BIAEo" + + "AjoBMBIPCgdmaWVsZDYzGD8gASgFEjgKBmdyb3VwMRgKIAMoCjIoLnByb3Rv" + + "Mi5iZW5jaG1hcmsudjJfYXBpLk1lc3NhZ2UzLkdyb3VwMRIRCghmaWVsZDEy" + + "OBiAASADKAkSEQoIZmllbGQxMzEYgwEgASgDEhAKCGZpZWxkMTI3GH8gAygJ" + + "EhEKCGZpZWxkMTI5GIEBIAEoBRIRCghmaWVsZDEzMBiCASADKAMSGAoIZmll" + + "bGQyMDUYzQEgASgIOgVmYWxzZRIYCghmaWVsZDIwNhjOASABKAg6BWZhbHNl" + + "Gr0CCgZHcm91cDESDwoHZmllbGQxMRgLIAIoAhIPCgdmaWVsZDI2GBogASgC" + + "Eg8KB2ZpZWxkMTIYDCABKAkSDwoHZmllbGQxMxgNIAEoCRIPCgdmaWVsZDE0" + + "GA4gAygJEg8KB2ZpZWxkMTUYDyACKAQSDgoGZmllbGQ1GAUgASgFEg8KB2Zp" + + "ZWxkMjcYGyABKAkSDwoHZmllbGQyOBgcIAEoBRIPCgdmaWVsZDI5GB0gASgJ" + + "Eg8KB2ZpZWxkMTYYECABKAkSDwoHZmllbGQyMhgWIAMoCRIPCgdmaWVsZDcz" + + "GEkgAygFEhIKB2ZpZWxkMjAYFCABKAU6ATASDwoHZmllbGQyNBgYIAEoCRIy" + + "CgdmaWVsZDMxGB8gASgLMiEucHJvdG8yLmJlbmNobWFyay52Ml9hcGkuTWVz" + + "c2FnZTQizAEKCE1lc3NhZ2U0Eg4KBmZpZWxkMRgBIAEoAhIOCgZmaWVsZDIY" + + "AiABKAISEQoGZmllbGQzGAMgASgCOgEwEg4KBmZpZWxkNBgEIAEoCBIOCgZm" + + "aWVsZDUYBSABKAgSFAoGZmllbGQ2GAYgASgIOgR0cnVlEhUKBmZpZWxkNxgH" + + "IAEoCDoFZmFsc2USDgoGZmllbGQ4GAggASgCEg4KBmZpZWxkORgJIAEoCBIP" + + "CgdmaWVsZDEwGAogASgCEg8KB2ZpZWxkMTEYCyABKANCQUgBwj48CiZHb29n" + + "bGUuUHJvdG9jb2xCdWZmZXJzLkJlbmNobWFya1Byb3RvcxISQmVuY2htYXJr" + + "UHJvdG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message1__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message1__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message1__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 readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message2__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message2__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message2__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 readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message3__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message3__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message3__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 readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message3_Group1__Descriptor + = internal__static_proto2_benchmark_v2_api_Message3__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message3_Group1__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message3_Group1__Descriptor, + new string[] { "Field11", "Field26", "Field12", "Field13", "Field14", "Field15", "Field5", "Field27", "Field28", "Field29", "Field16", "Field22", "Field73", "Field20", "Field24", "Field31", }); + internal static readonly pbd::MessageDescriptor internal__static_proto2_benchmark_v2_api_Message4__Descriptor + = Descriptor.MessageTypes[3]; + internal static pb::FieldAccess.FieldAccessorTable internal__static_proto2_benchmark_v2_api_Message4__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable(internal__static_proto2_benchmark_v2_api_Message4__Descriptor, + new string[] { "Field1", "Field2", "Field3", "Field4", "Field5", "Field6", "Field7", "Field8", "Field9", "Field10", "Field11", }); + #endregion + } + #region Messages + public sealed partial class Message1 : pb::GeneratedMessage { + private static readonly Message1 defaultInstance = new Builder().BuildPartial(); + public static Message1 DefaultInstance { + get { return defaultInstance; } + } + + public override Message1 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Message1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message1__FieldAccessorTable; } + } + + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + private bool hasField9; + private string field9_ = ""; + public bool HasField9 { + get { return hasField9; } + } + public string Field9 { + get { return field9_; } + } + + private bool hasField18; + private string field18_ = ""; + public bool HasField18 { + get { return hasField18; } + } + public string Field18 { + get { return field18_; } + } + + private bool hasField80; + private bool field80_ = false; + public bool HasField80 { + get { return hasField80; } + } + public bool Field80 { + get { return field80_; } + } + + private bool hasField81; + private bool field81_ = true; + public bool HasField81 { + get { return hasField81; } + } + public bool Field81 { + get { return field81_; } + } + + private bool hasField2; + private int field2_ = 0; + public bool HasField2 { + get { return hasField2; } + } + public int Field2 { + get { return field2_; } + } + + private bool hasField3; + private int field3_ = 0; + public bool HasField3 { + get { return hasField3; } + } + public int Field3 { + get { return field3_; } + } + + private bool hasField280; + private int field280_ = 0; + public bool HasField280 { + get { return hasField280; } + } + public int Field280 { + get { return field280_; } + } + + private bool hasField6; + private int field6_ = 0; + public bool HasField6 { + get { return hasField6; } + } + public int Field6 { + get { return field6_; } + } + + private bool hasField22; + private long field22_ = 0L; + public bool HasField22 { + get { return hasField22; } + } + public long Field22 { + get { return field22_; } + } + + private bool hasField4; + private string field4_ = ""; + public bool HasField4 { + get { return hasField4; } + } + public string Field4 { + get { return field4_; } + } + + private pbc::PopsicleList field5_ = new pbc::PopsicleList(); + public scg::IList Field5List { + get { return pbc::Lists.AsReadOnly(field5_); } + } + public int Field5Count { + get { return field5_.Count; } + } + public ulong GetField5(int index) { + return field5_[index]; + } + + private bool hasField59; + private bool field59_ = false; + public bool HasField59 { + get { return hasField59; } + } + public bool Field59 { + get { return field59_; } + } + + private bool hasField7; + private string field7_ = ""; + public bool HasField7 { + get { return hasField7; } + } + public string Field7 { + get { return field7_; } + } + + private bool hasField16; + private int field16_ = 0; + public bool HasField16 { + get { return hasField16; } + } + public int Field16 { + get { return field16_; } + } + + private bool hasField130; + private int field130_ = 0; + public bool HasField130 { + get { return hasField130; } + } + public int Field130 { + get { return field130_; } + } + + private bool hasField12; + private bool field12_ = true; + public bool HasField12 { + get { return hasField12; } + } + public bool Field12 { + get { return field12_; } + } + + private bool hasField17; + private bool field17_ = true; + public bool HasField17 { + get { return hasField17; } + } + public bool Field17 { + get { return field17_; } + } + + private bool hasField13; + private bool field13_ = true; + public bool HasField13 { + get { return hasField13; } + } + public bool Field13 { + get { return field13_; } + } + + private bool hasField14; + private bool field14_ = true; + public bool HasField14 { + get { return hasField14; } + } + public bool Field14 { + get { return field14_; } + } + + private bool hasField104; + private int field104_ = 0; + public bool HasField104 { + get { return hasField104; } + } + public int Field104 { + get { return field104_; } + } + + private bool hasField100; + private int field100_ = 0; + public bool HasField100 { + get { return hasField100; } + } + public int Field100 { + get { return field100_; } + } + + private bool hasField101; + private int field101_ = 0; + public bool HasField101 { + get { return hasField101; } + } + public int Field101 { + get { return field101_; } + } + + private bool hasField102; + private string field102_ = ""; + public bool HasField102 { + get { return hasField102; } + } + public string Field102 { + get { return field102_; } + } + + private bool hasField103; + private string field103_ = ""; + public bool HasField103 { + get { return hasField103; } + } + public string Field103 { + get { return field103_; } + } + + private bool hasField29; + private int field29_ = 0; + public bool HasField29 { + get { return hasField29; } + } + public int Field29 { + get { return field29_; } + } + + private bool hasField30; + private bool field30_ = false; + public bool HasField30 { + get { return hasField30; } + } + public bool Field30 { + get { return field30_; } + } + + private bool hasField60; + private int field60_ = -1; + public bool HasField60 { + get { return hasField60; } + } + public int Field60 { + get { return field60_; } + } + + private bool hasField271; + private int field271_ = -1; + public bool HasField271 { + get { return hasField271; } + } + public int Field271 { + get { return field271_; } + } + + private bool hasField272; + private int field272_ = -1; + public bool HasField272 { + get { return hasField272; } + } + public int Field272 { + get { return field272_; } + } + + private bool hasField150; + private int field150_ = 0; + public bool HasField150 { + get { return hasField150; } + } + public int Field150 { + get { return field150_; } + } + + private bool hasField23; + private int field23_ = 0; + public bool HasField23 { + get { return hasField23; } + } + public int Field23 { + get { return field23_; } + } + + private bool hasField24; + private bool field24_ = false; + public bool HasField24 { + get { return hasField24; } + } + public bool Field24 { + get { return field24_; } + } + + private bool hasField25; + private int field25_ = 0; + public bool HasField25 { + get { return hasField25; } + } + public int Field25 { + get { return field25_; } + } + + private bool hasField15; + private global::Google.ProtocolBuffers.BenchmarkProtos.Message2 field15_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message2.DefaultInstance; + public bool HasField15 { + get { return hasField15; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message2 Field15 { + get { return field15_; } + } + + private bool hasField78; + private bool field78_ = false; + public bool HasField78 { + get { return hasField78; } + } + public bool Field78 { + get { return field78_; } + } + + private bool hasField67; + private int field67_ = 0; + public bool HasField67 { + get { return hasField67; } + } + public int Field67 { + get { return field67_; } + } + + private bool hasField68; + private int field68_ = 0; + public bool HasField68 { + get { return hasField68; } + } + public int Field68 { + get { return field68_; } + } + + private bool hasField128; + private int field128_ = 0; + public bool HasField128 { + get { return hasField128; } + } + public int Field128 { + get { return field128_; } + } + + private bool hasField129; + private string field129_ = "xxxxxxxxxxxxxxxxxxxxx"; + public bool HasField129 { + get { return hasField129; } + } + public string Field129 { + get { return field129_; } + } + + 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) { + if (HasField1) { + output.WriteString(1, Field1); + } + if (HasField2) { + output.WriteInt32(2, Field2); + } + if (HasField3) { + output.WriteInt32(3, Field3); + } + if (HasField4) { + output.WriteString(4, Field4); + } + foreach (ulong element in Field5List) { + output.WriteFixed64(5, element); + } + if (HasField6) { + output.WriteInt32(6, Field6); + } + if (HasField7) { + output.WriteString(7, Field7); + } + if (HasField9) { + output.WriteString(9, Field9); + } + if (HasField12) { + output.WriteBool(12, Field12); + } + if (HasField13) { + output.WriteBool(13, Field13); + } + if (HasField14) { + output.WriteBool(14, Field14); + } + if (HasField15) { + output.WriteMessage(15, Field15); + } + if (HasField16) { + output.WriteInt32(16, Field16); + } + if (HasField17) { + output.WriteBool(17, Field17); + } + if (HasField18) { + output.WriteString(18, Field18); + } + if (HasField22) { + output.WriteInt64(22, Field22); + } + if (HasField23) { + output.WriteInt32(23, Field23); + } + if (HasField24) { + output.WriteBool(24, Field24); + } + if (HasField25) { + output.WriteInt32(25, Field25); + } + if (HasField29) { + output.WriteInt32(29, Field29); + } + if (HasField30) { + output.WriteBool(30, Field30); + } + if (HasField59) { + output.WriteBool(59, Field59); + } + if (HasField60) { + output.WriteInt32(60, Field60); + } + if (HasField67) { + output.WriteInt32(67, Field67); + } + if (HasField68) { + output.WriteInt32(68, Field68); + } + if (HasField78) { + output.WriteBool(78, Field78); + } + if (HasField80) { + output.WriteBool(80, Field80); + } + if (HasField81) { + output.WriteBool(81, Field81); + } + if (HasField100) { + output.WriteInt32(100, Field100); + } + if (HasField101) { + output.WriteInt32(101, Field101); + } + if (HasField102) { + output.WriteString(102, Field102); + } + if (HasField103) { + output.WriteString(103, Field103); + } + if (HasField104) { + output.WriteInt32(104, Field104); + } + if (HasField128) { + output.WriteInt32(128, Field128); + } + if (HasField129) { + output.WriteString(129, Field129); + } + if (HasField130) { + output.WriteInt32(130, Field130); + } + if (HasField131) { + output.WriteInt32(131, Field131); + } + if (HasField150) { + output.WriteInt32(150, Field150); + } + if (HasField271) { + output.WriteInt32(271, Field271); + } + if (HasField272) { + output.WriteInt32(272, Field272); + } + if (HasField280) { + output.WriteInt32(280, 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); + } + foreach (ulong element in Field5List) { + size += pb::CodedOutputStream.ComputeFixed64Size(5, element); + } + 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 Message1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Message1 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message1 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Message1 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Message1 result = new Message1(); + + protected override Message1 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Message1(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Message1.Descriptor; } + } + + public override Message1 DefaultInstanceForType { + get { return Message1.DefaultInstance; } + } + + public override Message1 BuildPartial() { + result.field5_.MakeReadOnly(); + Message1 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Message1) { + return MergeFrom((Message1) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Message1 other) { + if (other == Message1.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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + 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.BenchmarkProtos.Message2.Builder subBuilder = global::Google.ProtocolBuffers.BenchmarkProtos.Message2.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) { + 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) { + 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) { + 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) { + result.hasField4 = true; + result.field4_ = value; + return this; + } + public Builder ClearField4() { + result.hasField4 = false; + result.field4_ = ""; + return this; + } + + public scg::IList Field5List { + get { return result.field5_; } + } + public int Field5Count { + get { return result.Field5Count; } + } + public ulong GetField5(int index) { + return result.GetField5(index); + } + public Builder SetField5(int index, ulong value) { + result.field5_[index] = value; + return this; + } + public Builder AddField5(ulong value) { + result.field5_.Add(value); + return this; + } + public Builder AddRangeField5(scg::IEnumerable 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) { + 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) { + 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) { + 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.BenchmarkProtos.Message2 Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + public Builder SetField15(global::Google.ProtocolBuffers.BenchmarkProtos.Message2 value) { + result.hasField15 = true; + result.field15_ = value; + return this; + } + public Builder SetField15(global::Google.ProtocolBuffers.BenchmarkProtos.Message2.Builder builderForValue) { + result.hasField15 = true; + result.field15_ = builderForValue.Build(); + return this; + } + public Builder MergeField15(global::Google.ProtocolBuffers.BenchmarkProtos.Message2 value) { + if (result.HasField15 && + result.field15_ != global::Google.ProtocolBuffers.BenchmarkProtos.Message2.DefaultInstance) { + result.field15_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message2.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.BenchmarkProtos.Message2.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) { + 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; + } + } + } + + public sealed partial class Message2 : pb::GeneratedMessage { + private static readonly Message2 defaultInstance = new Builder().BuildPartial(); + public static Message2 DefaultInstance { + get { return defaultInstance; } + } + + public override Message2 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Message2 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message2__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message2__FieldAccessorTable; } + } + + private bool hasField1; + private int field1_ = 0; + public bool HasField1 { + get { return hasField1; } + } + public int Field1 { + get { return field1_; } + } + + private bool hasField2; + private int field2_ = 0; + public bool HasField2 { + get { return hasField2; } + } + public int Field2 { + get { return field2_; } + } + + private bool hasField3; + private int field3_ = 0; + public bool HasField3 { + get { return hasField3; } + } + public int Field3 { + get { return field3_; } + } + + private bool hasField15; + private string field15_ = ""; + public bool HasField15 { + get { return hasField15; } + } + public string Field15 { + get { return field15_; } + } + + private bool hasField12; + private bool field12_ = true; + public bool HasField12 { + get { return hasField12; } + } + public bool Field12 { + get { return field12_; } + } + + private bool hasField13; + private long field13_ = 0L; + public bool HasField13 { + get { return hasField13; } + } + public long Field13 { + get { return field13_; } + } + + private bool hasField14; + private long field14_ = 0L; + public bool HasField14 { + get { return hasField14; } + } + public long Field14 { + get { return field14_; } + } + + private bool hasField16; + private int field16_ = 0; + public bool HasField16 { + get { return hasField16; } + } + public int Field16 { + get { return field16_; } + } + + private bool hasField19; + private int field19_ = 2; + public bool HasField19 { + get { return hasField19; } + } + public int Field19 { + get { return field19_; } + } + + private bool hasField20; + private bool field20_ = true; + public bool HasField20 { + get { return hasField20; } + } + public bool Field20 { + get { return field20_; } + } + + private bool hasField28; + private bool field28_ = true; + public bool HasField28 { + get { return hasField28; } + } + public bool Field28 { + get { return field28_; } + } + + private bool hasField21; + private ulong field21_ = 0; + public bool HasField21 { + get { return hasField21; } + } + public ulong Field21 { + get { return field21_; } + } + + private bool hasField22; + private int field22_ = 0; + public bool HasField22 { + get { return hasField22; } + } + public int Field22 { + get { return field22_; } + } + + private bool hasField23; + private bool field23_ = false; + public bool HasField23 { + get { return hasField23; } + } + public bool Field23 { + get { return field23_; } + } + + private bool hasField206; + private bool field206_ = false; + public bool HasField206 { + get { return hasField206; } + } + public bool Field206 { + get { return field206_; } + } + + private bool hasField203; + private uint field203_ = 0; + public bool HasField203 { + get { return hasField203; } + } + public uint Field203 { + get { return field203_; } + } + + private bool hasField204; + private int field204_ = 0; + public bool HasField204 { + get { return hasField204; } + } + public int Field204 { + get { return field204_; } + } + + private bool hasField205; + private string field205_ = ""; + public bool HasField205 { + get { return hasField205; } + } + public string Field205 { + get { return field205_; } + } + + private bool hasField207; + private ulong field207_ = 0UL; + public bool HasField207 { + get { return hasField207; } + } + public ulong Field207 { + get { return field207_; } + } + + private bool hasField300; + private ulong field300_ = 0UL; + public bool HasField300 { + get { return hasField300; } + } + public ulong Field300 { + get { return field300_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasField1) { + output.WriteInt32(1, Field1); + } + if (HasField2) { + output.WriteInt32(2, Field2); + } + if (HasField3) { + output.WriteInt32(3, Field3); + } + if (HasField12) { + output.WriteBool(12, Field12); + } + if (HasField13) { + output.WriteInt64(13, Field13); + } + if (HasField14) { + output.WriteInt64(14, Field14); + } + if (HasField15) { + output.WriteString(15, Field15); + } + if (HasField16) { + output.WriteInt32(16, Field16); + } + if (HasField19) { + output.WriteInt32(19, Field19); + } + if (HasField20) { + output.WriteBool(20, Field20); + } + if (HasField21) { + output.WriteFixed64(21, Field21); + } + if (HasField22) { + output.WriteInt32(22, Field22); + } + if (HasField23) { + output.WriteBool(23, Field23); + } + if (HasField28) { + output.WriteBool(28, Field28); + } + if (HasField203) { + output.WriteFixed32(203, Field203); + } + if (HasField204) { + output.WriteInt32(204, Field204); + } + if (HasField205) { + output.WriteString(205, Field205); + } + if (HasField206) { + output.WriteBool(206, Field206); + } + if (HasField207) { + output.WriteUInt64(207, Field207); + } + if (HasField300) { + output.WriteUInt64(300, 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 Message2 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message2 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message2 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Message2 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message2 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Message2 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Message2 result = new Message2(); + + protected override Message2 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Message2(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Message2.Descriptor; } + } + + public override Message2 DefaultInstanceForType { + get { return Message2.DefaultInstance; } + } + + public override Message2 BuildPartial() { + Message2 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Message2) { + return MergeFrom((Message2) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Message2 other) { + if (other == Message2.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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + 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) { + 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; } + } + public ulong Field21 { + get { return result.Field21; } + set { SetField21(value); } + } + 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; } + } + public uint Field203 { + get { return result.Field203; } + set { SetField203(value); } + } + 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) { + 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; } + } + public ulong Field207 { + get { return result.Field207; } + set { SetField207(value); } + } + 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; } + } + public ulong Field300 { + get { return result.Field300; } + set { SetField300(value); } + } + public Builder SetField300(ulong value) { + result.hasField300 = true; + result.field300_ = value; + return this; + } + public Builder ClearField300() { + result.hasField300 = false; + result.field300_ = 0UL; + return this; + } + } + } + + public sealed partial class Message3 : pb::GeneratedMessage { + private static readonly Message3 defaultInstance = new Builder().BuildPartial(); + public static Message3 DefaultInstance { + get { return defaultInstance; } + } + + public override Message3 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Message3 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message3__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message3__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class Group1 : pb::GeneratedMessage { + 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.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message3_Group1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message3_Group1__FieldAccessorTable; } + } + + private bool hasField11; + private float field11_ = 0F; + public bool HasField11 { + get { return hasField11; } + } + public float Field11 { + get { return field11_; } + } + + private bool hasField26; + private float field26_ = 0F; + public bool HasField26 { + get { return hasField26; } + } + public float Field26 { + get { return field26_; } + } + + private bool hasField12; + private string field12_ = ""; + public bool HasField12 { + get { return hasField12; } + } + public string Field12 { + get { return field12_; } + } + + private bool hasField13; + private string field13_ = ""; + public bool HasField13 { + get { return hasField13; } + } + public string Field13 { + get { return field13_; } + } + + private pbc::PopsicleList field14_ = new pbc::PopsicleList(); + public scg::IList Field14List { + get { return pbc::Lists.AsReadOnly(field14_); } + } + public int Field14Count { + get { return field14_.Count; } + } + public string GetField14(int index) { + return field14_[index]; + } + + private bool hasField15; + private ulong field15_ = 0UL; + public bool HasField15 { + get { return hasField15; } + } + public ulong Field15 { + get { return field15_; } + } + + private bool hasField5; + private int field5_ = 0; + public bool HasField5 { + get { return hasField5; } + } + public int Field5 { + get { return field5_; } + } + + private bool hasField27; + private string field27_ = ""; + public bool HasField27 { + get { return hasField27; } + } + public string Field27 { + get { return field27_; } + } + + private bool hasField28; + private int field28_ = 0; + public bool HasField28 { + get { return hasField28; } + } + public int Field28 { + get { return field28_; } + } + + private bool hasField29; + private string field29_ = ""; + public bool HasField29 { + get { return hasField29; } + } + public string Field29 { + get { return field29_; } + } + + private bool hasField16; + private string field16_ = ""; + public bool HasField16 { + get { return hasField16; } + } + public string Field16 { + get { return field16_; } + } + + private pbc::PopsicleList field22_ = new pbc::PopsicleList(); + public scg::IList Field22List { + get { return pbc::Lists.AsReadOnly(field22_); } + } + public int Field22Count { + get { return field22_.Count; } + } + public string GetField22(int index) { + return field22_[index]; + } + + private pbc::PopsicleList field73_ = new pbc::PopsicleList(); + public scg::IList Field73List { + get { return pbc::Lists.AsReadOnly(field73_); } + } + public int Field73Count { + get { return field73_.Count; } + } + public int GetField73(int index) { + return field73_[index]; + } + + private bool hasField20; + private int field20_ = 0; + public bool HasField20 { + get { return hasField20; } + } + public int Field20 { + get { return field20_; } + } + + private bool hasField24; + private string field24_ = ""; + public bool HasField24 { + get { return hasField24; } + } + public string Field24 { + get { return field24_; } + } + + private bool hasField31; + private global::Google.ProtocolBuffers.BenchmarkProtos.Message4 field31_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message4.DefaultInstance; + public bool HasField31 { + get { return hasField31; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message4 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) { + if (HasField5) { + output.WriteInt32(5, Field5); + } + if (HasField11) { + output.WriteFloat(11, Field11); + } + if (HasField12) { + output.WriteString(12, Field12); + } + if (HasField13) { + output.WriteString(13, Field13); + } + foreach (string element in Field14List) { + output.WriteString(14, element); + } + if (HasField15) { + output.WriteUInt64(15, Field15); + } + if (HasField16) { + output.WriteString(16, Field16); + } + if (HasField20) { + output.WriteInt32(20, Field20); + } + foreach (string element in Field22List) { + output.WriteString(22, element); + } + if (HasField24) { + output.WriteString(24, Field24); + } + if (HasField26) { + output.WriteFloat(26, Field26); + } + if (HasField27) { + output.WriteString(27, Field27); + } + if (HasField28) { + output.WriteInt32(28, Field28); + } + if (HasField29) { + output.WriteString(29, Field29); + } + if (HasField31) { + output.WriteMessage(31, Field31); + } + foreach (int element in Field73List) { + output.WriteInt32(73, element); + } + 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); + } + foreach (string element in Field14List) { + size += pb::CodedOutputStream.ComputeStringSize(14, element); + } + 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); + } + foreach (string element in Field22List) { + size += pb::CodedOutputStream.ComputeStringSize(22, element); + } + foreach (int element in Field73List) { + size += pb::CodedOutputStream.ComputeInt32Size(73, element); + } + 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 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 CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Group1 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + 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 Group1.Descriptor; } + } + + public override Group1 DefaultInstanceForType { + get { return Group1.DefaultInstance; } + } + + public override Group1 BuildPartial() { + 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 == 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + 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.BenchmarkProtos.Message4.Builder subBuilder = global::Google.ProtocolBuffers.BenchmarkProtos.Message4.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) { + 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) { + result.hasField13 = true; + result.field13_ = value; + return this; + } + public Builder ClearField13() { + result.hasField13 = false; + result.field13_ = ""; + return this; + } + + public scg::IList 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) { + result.field14_[index] = value; + return this; + } + public Builder AddField14(string value) { + result.field14_.Add(value); + return this; + } + public Builder AddRangeField14(scg::IEnumerable values) { + base.AddRange(values, result.field14_); + return this; + } + public Builder ClearField14() { + result.field14_.Clear(); + return this; + } + + public bool HasField15 { + get { return result.HasField15; } + } + public ulong Field15 { + get { return result.Field15; } + set { SetField15(value); } + } + 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) { + 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) { + 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) { + result.hasField16 = true; + result.field16_ = value; + return this; + } + public Builder ClearField16() { + result.hasField16 = false; + result.field16_ = ""; + return this; + } + + public scg::IList 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) { + result.field22_[index] = value; + return this; + } + public Builder AddField22(string value) { + result.field22_.Add(value); + return this; + } + public Builder AddRangeField22(scg::IEnumerable values) { + base.AddRange(values, result.field22_); + return this; + } + public Builder ClearField22() { + result.field22_.Clear(); + return this; + } + + public scg::IList 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 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) { + 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.BenchmarkProtos.Message4 Field31 { + get { return result.Field31; } + set { SetField31(value); } + } + public Builder SetField31(global::Google.ProtocolBuffers.BenchmarkProtos.Message4 value) { + result.hasField31 = true; + result.field31_ = value; + return this; + } + public Builder SetField31(global::Google.ProtocolBuffers.BenchmarkProtos.Message4.Builder builderForValue) { + result.hasField31 = true; + result.field31_ = builderForValue.Build(); + return this; + } + public Builder MergeField31(global::Google.ProtocolBuffers.BenchmarkProtos.Message4 value) { + if (result.HasField31 && + result.field31_ != global::Google.ProtocolBuffers.BenchmarkProtos.Message4.DefaultInstance) { + result.field31_ = global::Google.ProtocolBuffers.BenchmarkProtos.Message4.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.BenchmarkProtos.Message4.DefaultInstance; + return this; + } + } + } + + } + #endregion + + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + private bool hasField3; + private long field3_ = 0L; + public bool HasField3 { + get { return hasField3; } + } + public long Field3 { + get { return field3_; } + } + + private bool hasField4; + private long field4_ = 0L; + public bool HasField4 { + get { return hasField4; } + } + public long Field4 { + get { return field4_; } + } + + private bool hasField30; + private long field30_ = 0L; + public bool HasField30 { + get { return hasField30; } + } + public long Field30 { + get { return field30_; } + } + + private bool hasField75; + private bool field75_ = false; + public bool HasField75 { + get { return hasField75; } + } + public bool Field75 { + get { return field75_; } + } + + private bool hasField6; + private string field6_ = ""; + public bool HasField6 { + get { return hasField6; } + } + public string Field6 { + get { return field6_; } + } + + private bool hasField2; + private pb::ByteString field2_ = pb::ByteString.Empty; + public bool HasField2 { + get { return hasField2; } + } + public pb::ByteString Field2 { + get { return field2_; } + } + + private bool hasField21; + private int field21_ = 0; + public bool HasField21 { + get { return hasField21; } + } + public int Field21 { + get { return field21_; } + } + + private bool hasField71; + private int field71_ = 0; + public bool HasField71 { + get { return hasField71; } + } + public int Field71 { + get { return field71_; } + } + + private bool hasField25; + private float field25_ = 0F; + public bool HasField25 { + get { return hasField25; } + } + public float Field25 { + get { return field25_; } + } + + private bool hasField109; + private int field109_ = 0; + public bool HasField109 { + get { return hasField109; } + } + public int Field109 { + get { return field109_; } + } + + private bool hasField210; + private int field210_ = 0; + public bool HasField210 { + get { return hasField210; } + } + public int Field210 { + get { return field210_; } + } + + private bool hasField211; + private int field211_ = 0; + public bool HasField211 { + get { return hasField211; } + } + public int Field211 { + get { return field211_; } + } + + private bool hasField212; + private int field212_ = 0; + public bool HasField212 { + get { return hasField212; } + } + public int Field212 { + get { return field212_; } + } + + private bool hasField213; + private int field213_ = 0; + public bool HasField213 { + get { return hasField213; } + } + public int Field213 { + get { return field213_; } + } + + private bool hasField216; + private int field216_ = 0; + public bool HasField216 { + get { return hasField216; } + } + public int Field216 { + get { return field216_; } + } + + private bool hasField217; + private int field217_ = 0; + public bool HasField217 { + get { return hasField217; } + } + public int Field217 { + get { return field217_; } + } + + private bool hasField218; + private int field218_ = 0; + public bool HasField218 { + get { return hasField218; } + } + public int Field218 { + get { return field218_; } + } + + private bool hasField220; + private int field220_ = 0; + public bool HasField220 { + get { return hasField220; } + } + public int Field220 { + get { return field220_; } + } + + private bool hasField221; + private int field221_ = 0; + public bool HasField221 { + get { return hasField221; } + } + public int Field221 { + get { return field221_; } + } + + private bool hasField222; + private float field222_ = 0F; + public bool HasField222 { + get { return hasField222; } + } + public float Field222 { + get { return field222_; } + } + + private bool hasField63; + private int field63_ = 0; + public bool HasField63 { + get { return hasField63; } + } + public int Field63 { + get { return field63_; } + } + + private pbc::PopsicleList group1_ = new pbc::PopsicleList(); + public scg::IList Group1List { + get { return group1_; } + } + public int Group1Count { + get { return group1_.Count; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 GetGroup1(int index) { + return group1_[index]; + } + + private pbc::PopsicleList field128_ = new pbc::PopsicleList(); + public scg::IList Field128List { + get { return pbc::Lists.AsReadOnly(field128_); } + } + public int Field128Count { + get { return field128_.Count; } + } + public string GetField128(int index) { + return field128_[index]; + } + + private bool hasField131; + private long field131_ = 0L; + public bool HasField131 { + get { return hasField131; } + } + public long Field131 { + get { return field131_; } + } + + private pbc::PopsicleList field127_ = new pbc::PopsicleList(); + public scg::IList Field127List { + get { return pbc::Lists.AsReadOnly(field127_); } + } + public int Field127Count { + get { return field127_.Count; } + } + public string GetField127(int index) { + return field127_[index]; + } + + private bool hasField129; + private int field129_ = 0; + public bool HasField129 { + get { return hasField129; } + } + public int Field129 { + get { return field129_; } + } + + private pbc::PopsicleList field130_ = new pbc::PopsicleList(); + public scg::IList Field130List { + get { return pbc::Lists.AsReadOnly(field130_); } + } + public int Field130Count { + get { return field130_.Count; } + } + public long GetField130(int index) { + return field130_[index]; + } + + private bool hasField205; + private bool field205_ = false; + public bool HasField205 { + get { return hasField205; } + } + public bool Field205 { + get { return field205_; } + } + + 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) { + if (HasField1) { + output.WriteString(1, Field1); + } + if (HasField2) { + output.WriteBytes(2, Field2); + } + if (HasField3) { + output.WriteInt64(3, Field3); + } + if (HasField4) { + output.WriteInt64(4, Field4); + } + if (HasField6) { + output.WriteString(6, Field6); + } + foreach (global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 element in Group1List) { + output.WriteGroup(10, element); + } + if (HasField21) { + output.WriteInt32(21, Field21); + } + if (HasField25) { + output.WriteFloat(25, Field25); + } + if (HasField30) { + output.WriteInt64(30, Field30); + } + if (HasField63) { + output.WriteInt32(63, Field63); + } + if (HasField71) { + output.WriteInt32(71, Field71); + } + if (HasField75) { + output.WriteBool(75, Field75); + } + if (HasField109) { + output.WriteInt32(109, Field109); + } + foreach (string element in Field127List) { + output.WriteString(127, element); + } + foreach (string element in Field128List) { + output.WriteString(128, element); + } + if (HasField129) { + output.WriteInt32(129, Field129); + } + foreach (long element in Field130List) { + output.WriteInt64(130, element); + } + if (HasField131) { + output.WriteInt64(131, Field131); + } + if (HasField205) { + output.WriteBool(205, Field205); + } + if (HasField206) { + output.WriteBool(206, Field206); + } + if (HasField210) { + output.WriteInt32(210, Field210); + } + if (HasField211) { + output.WriteInt32(211, Field211); + } + if (HasField212) { + output.WriteInt32(212, Field212); + } + if (HasField213) { + output.WriteInt32(213, Field213); + } + if (HasField216) { + output.WriteInt32(216, Field216); + } + if (HasField217) { + output.WriteInt32(217, Field217); + } + if (HasField218) { + output.WriteInt32(218, Field218); + } + if (HasField220) { + output.WriteInt32(220, Field220); + } + if (HasField221) { + output.WriteInt32(221, Field221); + } + if (HasField222) { + output.WriteFloat(222, 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.BenchmarkProtos.Message3.Types.Group1 element in Group1List) { + size += pb::CodedOutputStream.ComputeGroupSize(10, element); + } + foreach (string element in Field128List) { + size += pb::CodedOutputStream.ComputeStringSize(128, element); + } + if (HasField131) { + size += pb::CodedOutputStream.ComputeInt64Size(131, Field131); + } + foreach (string element in Field127List) { + size += pb::CodedOutputStream.ComputeStringSize(127, element); + } + if (HasField129) { + size += pb::CodedOutputStream.ComputeInt32Size(129, Field129); + } + foreach (long element in Field130List) { + size += pb::CodedOutputStream.ComputeInt64Size(130, element); + } + 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 Message3 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message3 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message3 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message3 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message3 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message3 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Message3 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message3 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Message3 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Message3 result = new Message3(); + + protected override Message3 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Message3(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Message3.Descriptor; } + } + + public override Message3 DefaultInstanceForType { + get { return Message3.DefaultInstance; } + } + + public override Message3 BuildPartial() { + result.group1_.MakeReadOnly(); + result.field128_.MakeReadOnly(); + result.field127_.MakeReadOnly(); + result.field130_.MakeReadOnly(); + Message3 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Message3) { + return MergeFrom((Message3) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Message3 other) { + if (other == Message3.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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + 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.BenchmarkProtos.Message3.Types.Group1.Builder subBuilder = global::Google.ProtocolBuffers.BenchmarkProtos.Message3.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) { + 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) { + 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) { + 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 scg::IList Group1List { + get { return result.group1_; } + } + public int Group1Count { + get { return result.Group1Count; } + } + public global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 GetGroup1(int index) { + return result.GetGroup1(index); + } + public Builder SetGroup1(int index, global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 value) { + result.group1_[index] = value; + return this; + } + public Builder SetGroup1(int index, global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1.Builder builderForValue) { + result.group1_[index] = builderForValue.Build(); + return this; + } + public Builder AddGroup1(global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1 value) { + result.group1_.Add(value); + return this; + } + public Builder AddGroup1(global::Google.ProtocolBuffers.BenchmarkProtos.Message3.Types.Group1.Builder builderForValue) { + result.group1_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeGroup1(scg::IEnumerable values) { + base.AddRange(values, result.group1_); + return this; + } + public Builder ClearGroup1() { + result.group1_.Clear(); + return this; + } + + public scg::IList 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) { + result.field128_[index] = value; + return this; + } + public Builder AddField128(string value) { + result.field128_.Add(value); + return this; + } + public Builder AddRangeField128(scg::IEnumerable 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 scg::IList 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) { + result.field127_[index] = value; + return this; + } + public Builder AddField127(string value) { + result.field127_.Add(value); + return this; + } + public Builder AddRangeField127(scg::IEnumerable 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 scg::IList 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 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; + } + } + } + + public sealed partial class Message4 : pb::GeneratedMessage { + private static readonly Message4 defaultInstance = new Builder().BuildPartial(); + public static Message4 DefaultInstance { + get { return defaultInstance; } + } + + public override Message4 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Message4 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message4__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.BenchmarkProtos.BenchmarkProtoFile.internal__static_proto2_benchmark_v2_api_Message4__FieldAccessorTable; } + } + + private bool hasField1; + private float field1_ = 0F; + public bool HasField1 { + get { return hasField1; } + } + public float Field1 { + get { return field1_; } + } + + private bool hasField2; + private float field2_ = 0F; + public bool HasField2 { + get { return hasField2; } + } + public float Field2 { + get { return field2_; } + } + + private bool hasField3; + private float field3_ = 0F; + public bool HasField3 { + get { return hasField3; } + } + public float Field3 { + get { return field3_; } + } + + private bool hasField4; + private bool field4_ = false; + public bool HasField4 { + get { return hasField4; } + } + public bool Field4 { + get { return field4_; } + } + + private bool hasField5; + private bool field5_ = false; + public bool HasField5 { + get { return hasField5; } + } + public bool Field5 { + get { return field5_; } + } + + private bool hasField6; + private bool field6_ = true; + public bool HasField6 { + get { return hasField6; } + } + public bool Field6 { + get { return field6_; } + } + + private bool hasField7; + private bool field7_ = false; + public bool HasField7 { + get { return hasField7; } + } + public bool Field7 { + get { return field7_; } + } + + private bool hasField8; + private float field8_ = 0F; + public bool HasField8 { + get { return hasField8; } + } + public float Field8 { + get { return field8_; } + } + + private bool hasField9; + private bool field9_ = false; + public bool HasField9 { + get { return hasField9; } + } + public bool Field9 { + get { return field9_; } + } + + private bool hasField10; + private float field10_ = 0F; + public bool HasField10 { + get { return hasField10; } + } + public float Field10 { + get { return field10_; } + } + + 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) { + if (HasField1) { + output.WriteFloat(1, Field1); + } + if (HasField2) { + output.WriteFloat(2, Field2); + } + if (HasField3) { + output.WriteFloat(3, Field3); + } + if (HasField4) { + output.WriteBool(4, Field4); + } + if (HasField5) { + output.WriteBool(5, Field5); + } + if (HasField6) { + output.WriteBool(6, Field6); + } + if (HasField7) { + output.WriteBool(7, Field7); + } + if (HasField8) { + output.WriteFloat(8, Field8); + } + if (HasField9) { + output.WriteBool(9, Field9); + } + if (HasField10) { + output.WriteFloat(10, Field10); + } + if (HasField11) { + output.WriteInt64(11, 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 Message4 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message4 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message4 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Message4 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Message4 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message4 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Message4 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Message4 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Message4 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Message4 result = new Message4(); + + protected override Message4 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Message4(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Message4.Descriptor; } + } + + public override Message4 DefaultInstanceForType { + get { return Message4.DefaultInstance; } + } + + public override Message4 BuildPartial() { + Message4 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Message4) { + return MergeFrom((Message4) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Message4 other) { + if (other == Message4.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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + 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; + } + } + } + + #endregion + +} diff --git a/src/ProtoBench/Program.cs b/src/ProtoBench/Program.cs new file mode 100644 index 0000000000..9b65c0b155 --- /dev/null +++ b/src/ProtoBench/Program.cs @@ -0,0 +1,90 @@ +using System; +using System.Diagnostics; +using System.IO; +using Google.ProtocolBuffers; + +namespace ProtoBench { + /// + /// Simple benchmarking of arbitrary messages. + /// + public sealed class Program { + + private static readonly TimeSpan MinSampleTime = TimeSpan.FromSeconds(2); + private static readonly TimeSpan TargetTime = TimeSpan.FromSeconds(30); + + // Avoid a .NET 3.5 dependency + delegate void Action(); + + public static int Main(string[] args) { + if (args.Length != 2) { + Console.Error.WriteLine("Usage: ProtoBecnh "); + Console.Error.WriteLine("The descriptor type name is the fully-qualified message name,"); + Console.Error.WriteLine("including assembly - e.g. Google.ProtocolBuffers.BenchmarkProtos.Message1,ProtoBench"); + return 1; + } + IMessage defaultMessage; + try { + defaultMessage = MessageUtil.GetDefaultMessage(args[0]); + } catch (ArgumentException e) { + Console.Error.WriteLine(e.Message); + return 1; + } + try { + IBuilder builder = defaultMessage.WeakCreateBuilderForType(); + byte[] inputData = File.ReadAllBytes(args[1]); + ByteString inputString = ByteString.CopyFrom(inputData); + IMessage sampleMessage = defaultMessage.WeakCreateBuilderForType().WeakMergeFrom(inputString).WeakBuild(); + sampleMessage.ToByteString(); + Console.WriteLine("Benchmarking {0} with file {1}", sampleMessage.GetType().Name, args[1]); + Benchmark("Serialize to byte string", inputData.Length, () => sampleMessage.ToByteString()); + Benchmark("Serialize to byte array", inputData.Length, () => sampleMessage.ToByteArray()); + Benchmark("Serialize to memory stream", inputData.Length, () => sampleMessage.WriteTo(new MemoryStream())); + Benchmark("Deserialize from byte array", inputData.Length, () => + defaultMessage.WeakCreateBuilderForType() + .WeakMergeFrom(CodedInputStream.CreateInstance(inputData)) + .WeakBuild() + ); + Benchmark("Deserialize from byte array", inputData.Length, () => + defaultMessage.WeakCreateBuilderForType() + .WeakMergeFrom(inputString) + .WeakBuild() + ); + return 0; + } catch (Exception e) { + Console.Error.WriteLine("Error: {0}", e.Message); + Console.Error.WriteLine(); + Console.Error.WriteLine("Detailed exception information: {0}", e); + return 1; + } + } + + private static void Benchmark(string name, int dataSize, Action action) { + // Make sure it's JITted + action(); + // Run it progressively more times until we've got a reasonable sample + + int iterations = 1; + TimeSpan elapsed = TimeAction(action, iterations); + while (elapsed < MinSampleTime) { + iterations *= 2; + elapsed = TimeAction(action, iterations); + } + // Upscale the sample to the target time. Do this in floating point arithmetic + // to avoid overflow issues. + iterations = (int) ((TargetTime.Ticks / (double)elapsed.Ticks) * iterations); + elapsed = TimeAction(action, iterations); + Console.WriteLine("{0}: {1} iterations in {2:f3}s; {3:f3}MB/s", + name, iterations, elapsed.TotalSeconds, + (iterations * dataSize) / (elapsed.TotalSeconds * 1024 * 1024)); + } + + private static TimeSpan TimeAction(Action action, int iterations) { + Stopwatch sw = Stopwatch.StartNew(); + for (int i = 0; i < iterations; i++) { + action(); + } + sw.Stop(); + return sw.Elapsed; + } + } +} diff --git a/src/ProtoBench/Properties/AssemblyInfo.cs b/src/ProtoBench/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..0d1f095d6e --- /dev/null +++ b/src/ProtoBench/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtoBench")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtoBench")] +[assembly: AssemblyCopyright("Copyright © 2009")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("0f515d09-9a6c-49ec-8500-14a5303ebadf")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/ProtoBench/ProtoBench.csproj b/src/ProtoBench/ProtoBench.csproj new file mode 100644 index 0000000000..fa24f5c8a0 --- /dev/null +++ b/src/ProtoBench/ProtoBench.csproj @@ -0,0 +1,62 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {C7A4A435-2813-41C8-AA87-BD914BA5223D} + Exe + Properties + Google.ProtocolBuffers.ProtoBench + ProtoBench + v2.0 + 512 + + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + {6908BDCE-D925-43F3-94AC-A531E6DF2591} + ProtocolBuffers + + + + + + + + \ No newline at end of file diff --git a/src/ProtoBench/app.config b/src/ProtoBench/app.config new file mode 100644 index 0000000000..df20690a1c --- /dev/null +++ b/src/ProtoBench/app.config @@ -0,0 +1,3 @@ + + + diff --git a/src/ProtoDump/Program.cs b/src/ProtoDump/Program.cs new file mode 100644 index 0000000000..0c66c93027 --- /dev/null +++ b/src/ProtoDump/Program.cs @@ -0,0 +1,43 @@ +using System; +using System.IO; +using System.Reflection; +using Google.ProtocolBuffers; + +namespace ProtoDump { + /// + /// Small utility to load a binary message and dump it in text form + /// + class Program { + static int Main(string[] args) { + if (args.Length != 2) { + Console.Error.WriteLine("Usage: ProtoDump "); + Console.Error.WriteLine("The descriptor type name is the fully-qualified message name,"); + Console.Error.WriteLine("including assembly e.g. ProjectNamespace.Message,Company.Project"); + return 1; + } + IMessage defaultMessage; + try { + defaultMessage = MessageUtil.GetDefaultMessage(args[0]); + } catch (ArgumentException e) { + Console.Error.WriteLine(e.Message); + return 1; + } + try { + IBuilder builder = defaultMessage.WeakCreateBuilderForType(); + if (builder == null) { + Console.Error.WriteLine("Unable to create builder"); + return 1; + } + byte[] inputData = File.ReadAllBytes(args[1]); + builder.WeakMergeFrom(ByteString.CopyFrom(inputData)); + Console.WriteLine(TextFormat.PrintToString(builder.WeakBuild())); + return 0; + } catch (Exception e) { + Console.Error.WriteLine("Error: {0}", e.Message); + Console.Error.WriteLine(); + Console.Error.WriteLine("Detailed exception information: {0}", e); + return 1; + } + } + } +} diff --git a/src/ProtoDump/Properties/AssemblyInfo.cs b/src/ProtoDump/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..93427f7cf5 --- /dev/null +++ b/src/ProtoDump/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtoDump")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtoDump")] +[assembly: AssemblyCopyright("Copyright © 2009")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("fed7572b-d747-4704-a6da-6c3c61088346")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/ProtoDump/ProtoDump.csproj b/src/ProtoDump/ProtoDump.csproj new file mode 100644 index 0000000000..db1ab3f4e1 --- /dev/null +++ b/src/ProtoDump/ProtoDump.csproj @@ -0,0 +1,59 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {D7282E99-2DC3-405B-946F-177DB2FD2AE2} + Exe + Properties + Google.ProtocolBuffers.ProtoDump + ProtoDump + v2.0 + 512 + + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + {6908BDCE-D925-43F3-94AC-A531E6DF2591} + ProtocolBuffers + + + + + + + + \ No newline at end of file diff --git a/src/ProtoDump/app.config b/src/ProtoDump/app.config new file mode 100644 index 0000000000..df20690a1c --- /dev/null +++ b/src/ProtoDump/app.config @@ -0,0 +1,3 @@ + + + diff --git a/src/ProtoGen.Test/DependencyResolutionTest.cs b/src/ProtoGen.Test/DependencyResolutionTest.cs index d9fca15ea7..afe9c81aac 100644 --- a/src/ProtoGen.Test/DependencyResolutionTest.cs +++ b/src/ProtoGen.Test/DependencyResolutionTest.cs @@ -1,10 +1,7 @@ -using System; using System.Collections.Generic; -using System.Text; +using Google.ProtocolBuffers.DescriptorProtos; using Google.ProtocolBuffers.Descriptors; using NUnit.Framework; -using Google.ProtocolBuffers.DescriptorProtos; -using Google.ProtocolBuffers.ProtoGen; namespace Google.ProtocolBuffers.ProtoGen { /// diff --git a/src/ProtoGen.Test/GeneratorTest.cs b/src/ProtoGen.Test/GeneratorTest.cs deleted file mode 100644 index d1beb585f2..0000000000 --- a/src/ProtoGen.Test/GeneratorTest.cs +++ /dev/null @@ -1,10 +0,0 @@ -using Google.ProtocolBuffers.DescriptorProtos; -using NUnit.Framework; -using Google.ProtocolBuffers.Descriptors; - -namespace Google.ProtocolBuffers.ProtoGen { - [TestFixture] - public class GeneratorTest { - - } -} \ No newline at end of file diff --git a/src/ProtoGen.Test/ProtoGen.Test.csproj b/src/ProtoGen.Test/ProtoGen.Test.csproj index 426431b288..33fe6e421f 100644 --- a/src/ProtoGen.Test/ProtoGen.Test.csproj +++ b/src/ProtoGen.Test/ProtoGen.Test.csproj @@ -45,7 +45,6 @@ - diff --git a/src/ProtoGen/Program.cs b/src/ProtoGen/Program.cs index e7d460897e..8a49759716 100644 --- a/src/ProtoGen/Program.cs +++ b/src/ProtoGen/Program.cs @@ -23,8 +23,6 @@ namespace Google.ProtocolBuffers.ProtoGen { Generator generator = Generator.CreateGenerator(options); generator.Generate(); - - return 0; } catch (Exception e) { Console.Error.WriteLine("Error: {0}", e.Message); diff --git a/src/ProtoMunge/Program.cs b/src/ProtoMunge/Program.cs new file mode 100644 index 0000000000..704f506034 --- /dev/null +++ b/src/ProtoMunge/Program.cs @@ -0,0 +1,228 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoMunge +{ + /// + /// Utility console application which takes a message descriptor and a corresponding message, + /// and produces a new message with similar but random data. The data is the same length + /// as the original, but with random values within appropriate bands. (For instance, a compressed + /// integer in the range 0-127 will end up as another integer in the same range, to keep the length + /// the same.) + /// TODO(jonskeet): Potentially refactor to use an instance instead, making it simpler to + /// be thread-safe for external use. + /// + public sealed class Program { + + static readonly Random rng = new Random(); + + static int Main(string[] args) { + if (args.Length != 3) { + Console.Error.WriteLine("Usage: ProtoMunge "); + Console.Error.WriteLine("The descriptor type name is the fully-qualified message name, including assembly."); + Console.Error.WriteLine("(At a future date it may be possible to do this without building the .NET assembly at all.)"); + return 1; + } + IMessage defaultMessage; + try { + defaultMessage = MessageUtil.GetDefaultMessage(args[0]); + } catch (ArgumentException e) { + Console.Error.WriteLine(e.Message); + return 1; + } + try { + IBuilder builder = defaultMessage.WeakCreateBuilderForType(); + byte[] inputData = File.ReadAllBytes(args[1]); + builder.WeakMergeFrom(ByteString.CopyFrom(inputData)); + IMessage original = builder.WeakBuild(); + IMessage munged = Munge(original); + if (original.SerializedSize != munged.SerializedSize) { + throw new Exception("Serialized sizes don't match"); + } + File.WriteAllBytes(args[2], munged.ToByteArray()); + return 0; + } catch (Exception e) { + Console.Error.WriteLine("Error: {0}", e.Message); + Console.Error.WriteLine(); + Console.Error.WriteLine("Detailed exception information: {0}", e); + return 1; + } + } + + /// + /// Munges a message recursively. + /// + /// A new message of the same type as the original message, + /// but munged so that all the data is desensitised. + private static IMessage Munge(IMessage message) { + IBuilder builder = message.WeakCreateBuilderForType(); + foreach (var pair in message.AllFields) { + if (pair.Key.IsRepeated) { + foreach (object singleValue in (IEnumerable)pair.Value) { + builder.WeakAddRepeatedField(pair.Key, CheckedMungeValue(pair.Key, singleValue)); + } + } else { + builder[pair.Key] = CheckedMungeValue(pair.Key, pair.Value); + } + } + IMessage munged = builder.WeakBuild(); + if (message.SerializedSize != munged.SerializedSize) { + Console.WriteLine("Sub message sizes: {0}/{1}", message.SerializedSize, munged.SerializedSize); + } + return munged; + } + + /// + /// Munges a single value and checks that the length ends up the same as it was before. + /// + private static object CheckedMungeValue(FieldDescriptor fieldDescriptor, object value) { + int currentSize = CodedOutputStream.ComputeFieldSize(fieldDescriptor.FieldType, fieldDescriptor.FieldNumber, value); + object mungedValue = MungeValue(fieldDescriptor, value); + int mungedSize = CodedOutputStream.ComputeFieldSize(fieldDescriptor.FieldType, fieldDescriptor.FieldNumber, mungedValue); + // Exceptions log more easily than assertions + if (currentSize != mungedSize) { + throw new Exception("Munged value had wrong size. Field type: " + fieldDescriptor.FieldType + + "; old value: " + value + "; new value: " + mungedValue); + } + return mungedValue; + } + + /// + /// Munges a single value of the specified field descriptor. (i.e. if the field is + /// actually a repeated int, this method receives a single int value to munge, and + /// is called multiple times). + /// + private static object MungeValue(FieldDescriptor fieldDescriptor, object value) { + switch (fieldDescriptor.FieldType) { + case FieldType.SInt64: + case FieldType.Int64: + return (long) MungeVarint64((ulong) (long)value); + case FieldType.UInt64: + return MungeVarint64((ulong)value); + case FieldType.SInt32: + return (int)MungeVarint32((uint)(int)value); + case FieldType.Int32: + return MungeInt32((int) value); + case FieldType.UInt32: + return MungeVarint32((uint)value); + case FieldType.Double: + return rng.NextDouble(); + case FieldType.Float: + return (float)rng.NextDouble(); + case FieldType.Fixed64: { + byte[] data = new byte[8]; + rng.NextBytes(data); + return BitConverter.ToUInt64(data, 0); + } + case FieldType.Fixed32: { + byte[] data = new byte[4]; + rng.NextBytes(data); + return BitConverter.ToUInt32(data, 0); + } + case FieldType.Bool: + return rng.Next(2) == 1; + case FieldType.String: + return MungeString((string)value); + case FieldType.Group: + case FieldType.Message: + return Munge((IMessage)value); + case FieldType.Bytes: + return MungeByteString((ByteString)value); + case FieldType.SFixed64: { + byte[] data = new byte[8]; + rng.NextBytes(data); + return BitConverter.ToInt64(data, 0); + } + case FieldType.SFixed32: { + byte[] data = new byte[4]; + rng.NextBytes(data); + return BitConverter.ToInt32(data, 0); + } + case FieldType.Enum: + return MungeEnum(fieldDescriptor, (int) value); + default: + // TODO(jonskeet): Different exception? + throw new ArgumentException("Invalid field descriptor"); + } + } + + private static object MungeString(string original) { + foreach (char c in original) { + if (c > 127) { + throw new ArgumentException("Can't handle non-ascii yet"); + } + } + char[] chars = new char[original.Length]; + // Convert to pure ASCII - no control characters. + for (int i = 0; i < chars.Length; i++) { + chars[i] = (char) rng.Next(32, 127); + } + return new string(chars); + } + + /// + /// Int32 fields are slightly strange - we need to keep the sign the same way it is: + /// negative numbers can munge to any other negative number (it'll always take + /// 10 bytes) but positive numbers have to stay positive, so we can't use the + /// full range of 32 bits. + /// + private static int MungeInt32(int value) { + if (value < 0) { + return rng.Next(int.MinValue, 0); + } + int length = CodedOutputStream.ComputeRawVarint32Size((uint) value); + uint min = length == 1 ? 0 : 1U << ((length - 1) * 7); + uint max = length == 5 ? int.MaxValue : (1U << (length * 7)) - 1; + return (int) NextRandomUInt64(min, max); + } + + private static uint MungeVarint32(uint original) { + int length = CodedOutputStream.ComputeRawVarint32Size(original); + uint min = length == 1 ? 0 : 1U << ((length - 1) * 7); + uint max = length == 5 ? uint.MaxValue : (1U << (length * 7)) - 1; + return (uint)NextRandomUInt64(min, max); + } + + private static ulong MungeVarint64(ulong original) { + int length = CodedOutputStream.ComputeRawVarint64Size(original); + ulong min = length == 1 ? 0 : 1UL << ((length - 1) * 7); + ulong max = length == 10 ? ulong.MaxValue : (1UL<< (length * 7)) - 1; + return NextRandomUInt64(min, max); + } + + /// + /// Returns a random number in the range [min, max] (both inclusive). + /// + private static ulong NextRandomUInt64(ulong min, ulong max) { + if (min > max) { + throw new ArgumentException("min must be <= max; min=" + min + "; max = " + max); + } + ulong range = max - min; + // This isn't actually terribly good at very large ranges - but it doesn't really matter for the sake + // of this program. + return min + (ulong)(range * rng.NextDouble()); + } + + private static object MungeEnum(FieldDescriptor fieldDescriptor, int original) { + // Find all the values which get encoded to the same size as the current value, and pick one at random + int originalSize = CodedOutputStream.ComputeRawVarint32Size((uint)original); + List sameSizeValues = new List (); + foreach (EnumValueDescriptor candidate in fieldDescriptor.EnumType.Values) { + if (CodedOutputStream.ComputeRawVarint32Size((uint)candidate.Number) == originalSize) { + sameSizeValues.Add(candidate); + } + } + return sameSizeValues[rng.Next(sameSizeValues.Count)].Number; + } + + private static object MungeByteString(ByteString byteString) { + byte[] data = new byte[byteString.Length]; + rng.NextBytes(data); + return ByteString.CopyFrom(data); + } + } +} \ No newline at end of file diff --git a/src/ProtoMunge/Properties/AssemblyInfo.cs b/src/ProtoMunge/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..179b04beba --- /dev/null +++ b/src/ProtoMunge/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtoMunge")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtoMunge")] +[assembly: AssemblyCopyright("Copyright © 2008")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("4d26ed0e-a6ca-4df9-bb87-59429d49b676")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/ProtoMunge/ProtoMunge.csproj b/src/ProtoMunge/ProtoMunge.csproj new file mode 100644 index 0000000000..f8a9af9a32 --- /dev/null +++ b/src/ProtoMunge/ProtoMunge.csproj @@ -0,0 +1,59 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {8F09AF72-3327-4FA7-BC09-070B80221AB9} + Exe + Properties + Google.ProtocolBuffers.ProtoMunge + ProtoMunge + v2.0 + 512 + + + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + {6908BDCE-D925-43F3-94AC-A531E6DF2591} + ProtocolBuffers + + + + + + + + \ No newline at end of file diff --git a/src/ProtoMunge/app.config b/src/ProtoMunge/app.config new file mode 100644 index 0000000000..df20690a1c --- /dev/null +++ b/src/ProtoMunge/app.config @@ -0,0 +1,3 @@ + + + diff --git a/src/ProtocolBuffers.Test/MessageUtilTest.cs b/src/ProtocolBuffers.Test/MessageUtilTest.cs new file mode 100644 index 0000000000..16495bf517 --- /dev/null +++ b/src/ProtocolBuffers.Test/MessageUtilTest.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class MessageUtilTest { + + [Test] + [ExpectedException(typeof(ArgumentNullException))] + public void NullTypeName() { + MessageUtil.GetDefaultMessage((string)null); + } + + [Test] + [ExpectedException(typeof(ArgumentException))] + public void InvalidTypeName() { + MessageUtil.GetDefaultMessage("invalidtypename"); + } + + [Test] + public void ValidTypeName() { + Assert.AreSame(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes).AssemblyQualifiedName)); + } + + [Test] + [ExpectedException(typeof(ArgumentNullException))] + public void NullType() { + MessageUtil.GetDefaultMessage((Type)null); + } + + [Test] + [ExpectedException(typeof(ArgumentException))] + public void NonMessageType() { + MessageUtil.GetDefaultMessage(typeof(string)); + } + + [Test] + public void ValidType() { + Assert.AreSame(TestAllTypes.DefaultInstance, MessageUtil.GetDefaultMessage(typeof(TestAllTypes))); + } + } +} diff --git a/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj index 277348cc55..2eb81e503d 100644 --- a/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj +++ b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -58,6 +58,7 @@ + diff --git a/src/ProtocolBuffers.sln b/src/ProtocolBuffers.sln index c2cd0bf6dd..cdcb2dbb09 100644 --- a/src/ProtocolBuffers.sln +++ b/src/ProtocolBuffers.sln @@ -11,6 +11,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoGen.Test", "ProtoGen.T EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AddressBook", "AddressBook\AddressBook.csproj", "{A31F5FB2-4FF3-432A-B35B-5CD203606311}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoMunge", "ProtoMunge\ProtoMunge.csproj", "{8F09AF72-3327-4FA7-BC09-070B80221AB9}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoBench", "ProtoBench\ProtoBench.csproj", "{C7A4A435-2813-41C8-AA87-BD914BA5223D}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoDump", "ProtoDump\ProtoDump.csproj", "{D7282E99-2DC3-405B-946F-177DB2FD2AE2}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -37,6 +43,18 @@ Global {A31F5FB2-4FF3-432A-B35B-5CD203606311}.Debug|Any CPU.Build.0 = Debug|Any CPU {A31F5FB2-4FF3-432A-B35B-5CD203606311}.Release|Any CPU.ActiveCfg = Release|Any CPU {A31F5FB2-4FF3-432A-B35B-5CD203606311}.Release|Any CPU.Build.0 = Release|Any CPU + {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8F09AF72-3327-4FA7-BC09-070B80221AB9}.Release|Any CPU.Build.0 = Release|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C7A4A435-2813-41C8-AA87-BD914BA5223D}.Release|Any CPU.Build.0 = Release|Any CPU + {D7282E99-2DC3-405B-946F-177DB2FD2AE2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D7282E99-2DC3-405B-946F-177DB2FD2AE2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D7282E99-2DC3-405B-946F-177DB2FD2AE2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D7282E99-2DC3-405B-946F-177DB2FD2AE2}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/ProtocolBuffers/ByteString.cs b/src/ProtocolBuffers/ByteString.cs index 53811205ae..0d67a53961 100644 --- a/src/ProtocolBuffers/ByteString.cs +++ b/src/ProtocolBuffers/ByteString.cs @@ -184,7 +184,7 @@ namespace Google.ProtocolBuffers { output = CodedOutputStream.CreateInstance(buffer); } - public ByteString Build() { + internal ByteString Build() { output.CheckNoSpaceLeft(); // We can be confident that the CodedOutputStream will not modify the @@ -193,7 +193,7 @@ namespace Google.ProtocolBuffers { return new ByteString(buffer); } - public CodedOutputStream CodedOutput { + internal CodedOutputStream CodedOutput { get { return output; } diff --git a/src/ProtocolBuffers/MessageUtil.cs b/src/ProtocolBuffers/MessageUtil.cs new file mode 100644 index 0000000000..d53af9c5c2 --- /dev/null +++ b/src/ProtocolBuffers/MessageUtil.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Text; + +namespace Google.ProtocolBuffers { + /// + /// Utilities for arbitrary messages of an unknown type. This class does not use + /// generics precisely because it is designed for dynamically discovered types. + /// + public static class MessageUtil { + + /// + /// Returns the default message for the given type. If an exception is thrown + /// (directly from this code), the message will be suitable to be displayed to a user. + /// + /// + /// The type parameter is null. + /// The type doesn't implement IMessage, or doesn't + /// have a static DefaultMessage property of the same type, or is generic or abstract. + /// + public static IMessage GetDefaultMessage(Type type) { + if (type == null) { + throw new ArgumentNullException("type", "No type specified."); + } + if (type.IsAbstract || type.IsGenericTypeDefinition) { + throw new ArgumentException("Unable to get a default message for an abstract or generic type (" + type.FullName + ")"); + } + if (!typeof(IMessage).IsAssignableFrom(type)) { + throw new ArgumentException("Unable to get a default message for non-message type (" + type.FullName + ")"); + } + PropertyInfo property = type.GetProperty("DefaultInstance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); + if (property == null) { + throw new ArgumentException(type.FullName + " doesn't have a static DefaultInstance property"); + } + if (property.PropertyType != type) { + throw new ArgumentException(type.FullName + ".DefaultInstance property is of the wrong type"); + } + return (IMessage) property.GetValue(null, null); + } + + /// + /// Returns the default message for the type with the given name. This is just + /// a convenience wrapper around calling Type.GetType and then GetDefaultMessage. + /// If an exception is thrown, the message will be suitable to be displayed to a user. + /// + /// + /// The typeName parameter is null. + /// The type doesn't implement IMessage, or doesn't + /// have a static DefaultMessage property of the same type, or can't be found. + public static IMessage GetDefaultMessage(string typeName) { + if (typeName == null) { + throw new ArgumentNullException("typeName", "No type name specified."); + } + Type type = Type.GetType(typeName); + if (type == null) { + throw new ArgumentException("Unable to load type " + typeName); + } + return GetDefaultMessage(type); + } + } +} diff --git a/src/ProtocolBuffers/ProtocolBuffers.csproj b/src/ProtocolBuffers/ProtocolBuffers.csproj index 6a746cc938..520594f547 100644 --- a/src/ProtocolBuffers/ProtocolBuffers.csproj +++ b/src/ProtocolBuffers/ProtocolBuffers.csproj @@ -97,6 +97,7 @@ + diff --git a/testdata/benchmark_message1.dat b/testdata/benchmark_message1.dat new file mode 100644 index 0000000000..02f410b163 Binary files /dev/null and b/testdata/benchmark_message1.dat differ diff --git a/testdata/benchmark_message2.dat b/testdata/benchmark_message2.dat new file mode 100644 index 0000000000..06c09441b9 Binary files /dev/null and b/testdata/benchmark_message2.dat differ