1 // <auto-generated> 2 // Generated by the protocol buffer compiler. DO NOT EDIT! 3 // source: src/proto/grpc/testing/control.proto 4 // </auto-generated> 5 #pragma warning disable 1591, 0612, 3021 6 #region Designer generated code 7 8 using pb = global::Google.Protobuf; 9 using pbc = global::Google.Protobuf.Collections; 10 using pbr = global::Google.Protobuf.Reflection; 11 using scg = global::System.Collections.Generic; 12 namespace Grpc.Testing { 13 14 /// <summary>Holder for reflection information generated from src/proto/grpc/testing/control.proto</summary> 15 public static partial class ControlReflection { 16 17 #region Descriptor 18 /// <summary>File descriptor for src/proto/grpc/testing/control.proto</summary> 19 public static pbr::FileDescriptor Descriptor { 20 get { return descriptor; } 21 } 22 private static pbr::FileDescriptor descriptor; 23 ControlReflection()24 static ControlReflection() { 25 byte[] descriptorData = global::System.Convert.FromBase64String( 26 string.Concat( 27 "CiRzcmMvcHJvdG8vZ3JwYy90ZXN0aW5nL2NvbnRyb2wucHJvdG8SDGdycGMu", 28 "dGVzdGluZxolc3JjL3Byb3RvL2dycGMvdGVzdGluZy9wYXlsb2Fkcy5wcm90", 29 "bxoic3JjL3Byb3RvL2dycGMvdGVzdGluZy9zdGF0cy5wcm90byIlCg1Qb2lz", 30 "c29uUGFyYW1zEhQKDG9mZmVyZWRfbG9hZBgBIAEoASISChBDbG9zZWRMb29w", 31 "UGFyYW1zInsKCkxvYWRQYXJhbXMSNQoLY2xvc2VkX2xvb3AYASABKAsyHi5n", 32 "cnBjLnRlc3RpbmcuQ2xvc2VkTG9vcFBhcmFtc0gAEi4KB3BvaXNzb24YAiAB", 33 "KAsyGy5ncnBjLnRlc3RpbmcuUG9pc3NvblBhcmFtc0gAQgYKBGxvYWQiVgoO", 34 "U2VjdXJpdHlQYXJhbXMSEwoLdXNlX3Rlc3RfY2EYASABKAgSHAoUc2VydmVy", 35 "X2hvc3Rfb3ZlcnJpZGUYAiABKAkSEQoJY3JlZF90eXBlGAMgASgJIk0KCkNo", 36 "YW5uZWxBcmcSDAoEbmFtZRgBIAEoCRITCglzdHJfdmFsdWUYAiABKAlIABIT", 37 "CglpbnRfdmFsdWUYAyABKAVIAEIHCgV2YWx1ZSK8BQoMQ2xpZW50Q29uZmln", 38 "EhYKDnNlcnZlcl90YXJnZXRzGAEgAygJEi0KC2NsaWVudF90eXBlGAIgASgO", 39 "MhguZ3JwYy50ZXN0aW5nLkNsaWVudFR5cGUSNQoPc2VjdXJpdHlfcGFyYW1z", 40 "GAMgASgLMhwuZ3JwYy50ZXN0aW5nLlNlY3VyaXR5UGFyYW1zEiQKHG91dHN0", 41 "YW5kaW5nX3JwY3NfcGVyX2NoYW5uZWwYBCABKAUSFwoPY2xpZW50X2NoYW5u", 42 "ZWxzGAUgASgFEhwKFGFzeW5jX2NsaWVudF90aHJlYWRzGAcgASgFEicKCHJw", 43 "Y190eXBlGAggASgOMhUuZ3JwYy50ZXN0aW5nLlJwY1R5cGUSLQoLbG9hZF9w", 44 "YXJhbXMYCiABKAsyGC5ncnBjLnRlc3RpbmcuTG9hZFBhcmFtcxIzCg5wYXls", 45 "b2FkX2NvbmZpZxgLIAEoCzIbLmdycGMudGVzdGluZy5QYXlsb2FkQ29uZmln", 46 "EjcKEGhpc3RvZ3JhbV9wYXJhbXMYDCABKAsyHS5ncnBjLnRlc3RpbmcuSGlz", 47 "dG9ncmFtUGFyYW1zEhEKCWNvcmVfbGlzdBgNIAMoBRISCgpjb3JlX2xpbWl0", 48 "GA4gASgFEhgKEG90aGVyX2NsaWVudF9hcGkYDyABKAkSLgoMY2hhbm5lbF9h", 49 "cmdzGBAgAygLMhguZ3JwYy50ZXN0aW5nLkNoYW5uZWxBcmcSFgoOdGhyZWFk", 50 "c19wZXJfY3EYESABKAUSGwoTbWVzc2FnZXNfcGVyX3N0cmVhbRgSIAEoBRIY", 51 "ChB1c2VfY29hbGVzY2VfYXBpGBMgASgIEjEKKW1lZGlhbl9sYXRlbmN5X2Nv", 52 "bGxlY3Rpb25faW50ZXJ2YWxfbWlsbGlzGBQgASgFEhgKEGNsaWVudF9wcm9j", 53 "ZXNzZXMYFSABKAUiOAoMQ2xpZW50U3RhdHVzEigKBXN0YXRzGAEgASgLMhku", 54 "Z3JwYy50ZXN0aW5nLkNsaWVudFN0YXRzIhUKBE1hcmsSDQoFcmVzZXQYASAB", 55 "KAgiaAoKQ2xpZW50QXJncxIrCgVzZXR1cBgBIAEoCzIaLmdycGMudGVzdGlu", 56 "Zy5DbGllbnRDb25maWdIABIiCgRtYXJrGAIgASgLMhIuZ3JwYy50ZXN0aW5n", 57 "Lk1hcmtIAEIJCgdhcmd0eXBlIpcDCgxTZXJ2ZXJDb25maWcSLQoLc2VydmVy", 58 "X3R5cGUYASABKA4yGC5ncnBjLnRlc3RpbmcuU2VydmVyVHlwZRI1Cg9zZWN1", 59 "cml0eV9wYXJhbXMYAiABKAsyHC5ncnBjLnRlc3RpbmcuU2VjdXJpdHlQYXJh", 60 "bXMSDAoEcG9ydBgEIAEoBRIcChRhc3luY19zZXJ2ZXJfdGhyZWFkcxgHIAEo", 61 "BRISCgpjb3JlX2xpbWl0GAggASgFEjMKDnBheWxvYWRfY29uZmlnGAkgASgL", 62 "MhsuZ3JwYy50ZXN0aW5nLlBheWxvYWRDb25maWcSEQoJY29yZV9saXN0GAog", 63 "AygFEhgKEG90aGVyX3NlcnZlcl9hcGkYCyABKAkSFgoOdGhyZWFkc19wZXJf", 64 "Y3EYDCABKAUSHAoTcmVzb3VyY2VfcXVvdGFfc2l6ZRjpByABKAUSLwoMY2hh", 65 "bm5lbF9hcmdzGOoHIAMoCzIYLmdycGMudGVzdGluZy5DaGFubmVsQXJnEhgK", 66 "EHNlcnZlcl9wcm9jZXNzZXMYFSABKAUiaAoKU2VydmVyQXJncxIrCgVzZXR1", 67 "cBgBIAEoCzIaLmdycGMudGVzdGluZy5TZXJ2ZXJDb25maWdIABIiCgRtYXJr", 68 "GAIgASgLMhIuZ3JwYy50ZXN0aW5nLk1hcmtIAEIJCgdhcmd0eXBlIlUKDFNl", 69 "cnZlclN0YXR1cxIoCgVzdGF0cxgBIAEoCzIZLmdycGMudGVzdGluZy5TZXJ2", 70 "ZXJTdGF0cxIMCgRwb3J0GAIgASgFEg0KBWNvcmVzGAMgASgFIg0KC0NvcmVS", 71 "ZXF1ZXN0Ih0KDENvcmVSZXNwb25zZRINCgVjb3JlcxgBIAEoBSIGCgRWb2lk", 72 "Iv0BCghTY2VuYXJpbxIMCgRuYW1lGAEgASgJEjEKDWNsaWVudF9jb25maWcY", 73 "AiABKAsyGi5ncnBjLnRlc3RpbmcuQ2xpZW50Q29uZmlnEhMKC251bV9jbGll", 74 "bnRzGAMgASgFEjEKDXNlcnZlcl9jb25maWcYBCABKAsyGi5ncnBjLnRlc3Rp", 75 "bmcuU2VydmVyQ29uZmlnEhMKC251bV9zZXJ2ZXJzGAUgASgFEhYKDndhcm11", 76 "cF9zZWNvbmRzGAYgASgFEhkKEWJlbmNobWFya19zZWNvbmRzGAcgASgFEiAK", 77 "GHNwYXduX2xvY2FsX3dvcmtlcl9jb3VudBgIIAEoBSI2CglTY2VuYXJpb3MS", 78 "KQoJc2NlbmFyaW9zGAEgAygLMhYuZ3JwYy50ZXN0aW5nLlNjZW5hcmlvIoQE", 79 "ChVTY2VuYXJpb1Jlc3VsdFN1bW1hcnkSCwoDcXBzGAEgASgBEhsKE3Fwc19w", 80 "ZXJfc2VydmVyX2NvcmUYAiABKAESGgoSc2VydmVyX3N5c3RlbV90aW1lGAMg", 81 "ASgBEhgKEHNlcnZlcl91c2VyX3RpbWUYBCABKAESGgoSY2xpZW50X3N5c3Rl", 82 "bV90aW1lGAUgASgBEhgKEGNsaWVudF91c2VyX3RpbWUYBiABKAESEgoKbGF0", 83 "ZW5jeV81MBgHIAEoARISCgpsYXRlbmN5XzkwGAggASgBEhIKCmxhdGVuY3lf", 84 "OTUYCSABKAESEgoKbGF0ZW5jeV85ORgKIAEoARITCgtsYXRlbmN5Xzk5ORgL", 85 "IAEoARIYChBzZXJ2ZXJfY3B1X3VzYWdlGAwgASgBEiYKHnN1Y2Nlc3NmdWxf", 86 "cmVxdWVzdHNfcGVyX3NlY29uZBgNIAEoARIiChpmYWlsZWRfcmVxdWVzdHNf", 87 "cGVyX3NlY29uZBgOIAEoARIgChhjbGllbnRfcG9sbHNfcGVyX3JlcXVlc3QY", 88 "DyABKAESIAoYc2VydmVyX3BvbGxzX3Blcl9yZXF1ZXN0GBAgASgBEiIKGnNl", 89 "cnZlcl9xdWVyaWVzX3Blcl9jcHVfc2VjGBEgASgBEiIKGmNsaWVudF9xdWVy", 90 "aWVzX3Blcl9jcHVfc2VjGBIgASgBIoMDCg5TY2VuYXJpb1Jlc3VsdBIoCghz", 91 "Y2VuYXJpbxgBIAEoCzIWLmdycGMudGVzdGluZy5TY2VuYXJpbxIuCglsYXRl", 92 "bmNpZXMYAiABKAsyGy5ncnBjLnRlc3RpbmcuSGlzdG9ncmFtRGF0YRIvCgxj", 93 "bGllbnRfc3RhdHMYAyADKAsyGS5ncnBjLnRlc3RpbmcuQ2xpZW50U3RhdHMS", 94 "LwoMc2VydmVyX3N0YXRzGAQgAygLMhkuZ3JwYy50ZXN0aW5nLlNlcnZlclN0", 95 "YXRzEhQKDHNlcnZlcl9jb3JlcxgFIAMoBRI0CgdzdW1tYXJ5GAYgASgLMiMu", 96 "Z3JwYy50ZXN0aW5nLlNjZW5hcmlvUmVzdWx0U3VtbWFyeRIWCg5jbGllbnRf", 97 "c3VjY2VzcxgHIAMoCBIWCg5zZXJ2ZXJfc3VjY2VzcxgIIAMoCBI5Cg9yZXF1", 98 "ZXN0X3Jlc3VsdHMYCSADKAsyIC5ncnBjLnRlc3RpbmcuUmVxdWVzdFJlc3Vs", 99 "dENvdW50KlYKCkNsaWVudFR5cGUSDwoLU1lOQ19DTElFTlQQABIQCgxBU1lO", 100 "Q19DTElFTlQQARIQCgxPVEhFUl9DTElFTlQQAhITCg9DQUxMQkFDS19DTElF", 101 "TlQQAypwCgpTZXJ2ZXJUeXBlEg8KC1NZTkNfU0VSVkVSEAASEAoMQVNZTkNf", 102 "U0VSVkVSEAESGAoUQVNZTkNfR0VORVJJQ19TRVJWRVIQAhIQCgxPVEhFUl9T", 103 "RVJWRVIQAxITCg9DQUxMQkFDS19TRVJWRVIQBCpyCgdScGNUeXBlEgkKBVVO", 104 "QVJZEAASDQoJU1RSRUFNSU5HEAESGQoVU1RSRUFNSU5HX0ZST01fQ0xJRU5U", 105 "EAISGQoVU1RSRUFNSU5HX0ZST01fU0VSVkVSEAMSFwoTU1RSRUFNSU5HX0JP", 106 "VEhfV0FZUxAEYgZwcm90bzM=")); 107 descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, 108 new pbr::FileDescriptor[] { global::Grpc.Testing.PayloadsReflection.Descriptor, global::Grpc.Testing.StatsReflection.Descriptor, }, 109 new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Grpc.Testing.ClientType), typeof(global::Grpc.Testing.ServerType), typeof(global::Grpc.Testing.RpcType), }, null, new pbr::GeneratedClrTypeInfo[] { 110 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.PoissonParams), global::Grpc.Testing.PoissonParams.Parser, new[]{ "OfferedLoad" }, null, null, null, null), 111 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClosedLoopParams), global::Grpc.Testing.ClosedLoopParams.Parser, null, null, null, null, null), 112 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.LoadParams), global::Grpc.Testing.LoadParams.Parser, new[]{ "ClosedLoop", "Poisson" }, new[]{ "Load" }, null, null, null), 113 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.SecurityParams), global::Grpc.Testing.SecurityParams.Parser, new[]{ "UseTestCa", "ServerHostOverride", "CredType" }, null, null, null, null), 114 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ChannelArg), global::Grpc.Testing.ChannelArg.Parser, new[]{ "Name", "StrValue", "IntValue" }, new[]{ "Value" }, null, null, null), 115 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClientConfig), global::Grpc.Testing.ClientConfig.Parser, new[]{ "ServerTargets", "ClientType", "SecurityParams", "OutstandingRpcsPerChannel", "ClientChannels", "AsyncClientThreads", "RpcType", "LoadParams", "PayloadConfig", "HistogramParams", "CoreList", "CoreLimit", "OtherClientApi", "ChannelArgs", "ThreadsPerCq", "MessagesPerStream", "UseCoalesceApi", "MedianLatencyCollectionIntervalMillis", "ClientProcesses" }, null, null, null, null), 116 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClientStatus), global::Grpc.Testing.ClientStatus.Parser, new[]{ "Stats" }, null, null, null, null), 117 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.Mark), global::Grpc.Testing.Mark.Parser, new[]{ "Reset" }, null, null, null, null), 118 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClientArgs), global::Grpc.Testing.ClientArgs.Parser, new[]{ "Setup", "Mark" }, new[]{ "Argtype" }, null, null, null), 119 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ServerConfig), global::Grpc.Testing.ServerConfig.Parser, new[]{ "ServerType", "SecurityParams", "Port", "AsyncServerThreads", "CoreLimit", "PayloadConfig", "CoreList", "OtherServerApi", "ThreadsPerCq", "ResourceQuotaSize", "ChannelArgs", "ServerProcesses" }, null, null, null, null), 120 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ServerArgs), global::Grpc.Testing.ServerArgs.Parser, new[]{ "Setup", "Mark" }, new[]{ "Argtype" }, null, null, null), 121 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ServerStatus), global::Grpc.Testing.ServerStatus.Parser, new[]{ "Stats", "Port", "Cores" }, null, null, null, null), 122 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.CoreRequest), global::Grpc.Testing.CoreRequest.Parser, null, null, null, null, null), 123 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.CoreResponse), global::Grpc.Testing.CoreResponse.Parser, new[]{ "Cores" }, null, null, null, null), 124 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.Void), global::Grpc.Testing.Void.Parser, null, null, null, null, null), 125 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.Scenario), global::Grpc.Testing.Scenario.Parser, new[]{ "Name", "ClientConfig", "NumClients", "ServerConfig", "NumServers", "WarmupSeconds", "BenchmarkSeconds", "SpawnLocalWorkerCount" }, null, null, null, null), 126 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.Scenarios), global::Grpc.Testing.Scenarios.Parser, new[]{ "Scenarios_" }, null, null, null, null), 127 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ScenarioResultSummary), global::Grpc.Testing.ScenarioResultSummary.Parser, new[]{ "Qps", "QpsPerServerCore", "ServerSystemTime", "ServerUserTime", "ClientSystemTime", "ClientUserTime", "Latency50", "Latency90", "Latency95", "Latency99", "Latency999", "ServerCpuUsage", "SuccessfulRequestsPerSecond", "FailedRequestsPerSecond", "ClientPollsPerRequest", "ServerPollsPerRequest", "ServerQueriesPerCpuSec", "ClientQueriesPerCpuSec" }, null, null, null, null), 128 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ScenarioResult), global::Grpc.Testing.ScenarioResult.Parser, new[]{ "Scenario", "Latencies", "ClientStats", "ServerStats", "ServerCores", "Summary", "ClientSuccess", "ServerSuccess", "RequestResults" }, null, null, null, null) 129 })); 130 } 131 #endregion 132 133 } 134 #region Enums 135 public enum ClientType { 136 /// <summary> 137 /// Many languages support a basic distinction between using 138 /// sync or async client, and this allows the specification 139 /// </summary> 140 [pbr::OriginalName("SYNC_CLIENT")] SyncClient = 0, 141 [pbr::OriginalName("ASYNC_CLIENT")] AsyncClient = 1, 142 /// <summary> 143 /// used for some language-specific variants 144 /// </summary> 145 [pbr::OriginalName("OTHER_CLIENT")] OtherClient = 2, 146 [pbr::OriginalName("CALLBACK_CLIENT")] CallbackClient = 3, 147 } 148 149 public enum ServerType { 150 [pbr::OriginalName("SYNC_SERVER")] SyncServer = 0, 151 [pbr::OriginalName("ASYNC_SERVER")] AsyncServer = 1, 152 [pbr::OriginalName("ASYNC_GENERIC_SERVER")] AsyncGenericServer = 2, 153 /// <summary> 154 /// used for some language-specific variants 155 /// </summary> 156 [pbr::OriginalName("OTHER_SERVER")] OtherServer = 3, 157 [pbr::OriginalName("CALLBACK_SERVER")] CallbackServer = 4, 158 } 159 160 public enum RpcType { 161 [pbr::OriginalName("UNARY")] Unary = 0, 162 [pbr::OriginalName("STREAMING")] Streaming = 1, 163 [pbr::OriginalName("STREAMING_FROM_CLIENT")] StreamingFromClient = 2, 164 [pbr::OriginalName("STREAMING_FROM_SERVER")] StreamingFromServer = 3, 165 [pbr::OriginalName("STREAMING_BOTH_WAYS")] StreamingBothWays = 4, 166 } 167 168 #endregion 169 170 #region Messages 171 /// <summary> 172 /// Parameters of poisson process distribution, which is a good representation 173 /// of activity coming in from independent identical stationary sources. 174 /// </summary> 175 public sealed partial class PoissonParams : pb::IMessage<PoissonParams> 176 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 177 , pb::IBufferMessage 178 #endif 179 { 180 private static readonly pb::MessageParser<PoissonParams> _parser = new pb::MessageParser<PoissonParams>(() => new PoissonParams()); 181 private pb::UnknownFieldSet _unknownFields; 182 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 183 public static pb::MessageParser<PoissonParams> Parser { get { return _parser; } } 184 185 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 186 public static pbr::MessageDescriptor Descriptor { 187 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[0]; } 188 } 189 190 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 191 pbr::MessageDescriptor pb::IMessage.Descriptor { 192 get { return Descriptor; } 193 } 194 195 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] PoissonParams()196 public PoissonParams() { 197 OnConstruction(); 198 } 199 OnConstruction()200 partial void OnConstruction(); 201 202 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] PoissonParams(PoissonParams other)203 public PoissonParams(PoissonParams other) : this() { 204 offeredLoad_ = other.offeredLoad_; 205 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 206 } 207 208 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()209 public PoissonParams Clone() { 210 return new PoissonParams(this); 211 } 212 213 /// <summary>Field number for the "offered_load" field.</summary> 214 public const int OfferedLoadFieldNumber = 1; 215 private double offeredLoad_; 216 /// <summary> 217 /// The rate of arrivals (a.k.a. lambda parameter of the exp distribution). 218 /// </summary> 219 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 220 public double OfferedLoad { 221 get { return offeredLoad_; } 222 set { 223 offeredLoad_ = value; 224 } 225 } 226 227 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)228 public override bool Equals(object other) { 229 return Equals(other as PoissonParams); 230 } 231 232 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(PoissonParams other)233 public bool Equals(PoissonParams other) { 234 if (ReferenceEquals(other, null)) { 235 return false; 236 } 237 if (ReferenceEquals(other, this)) { 238 return true; 239 } 240 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(OfferedLoad, other.OfferedLoad)) return false; 241 return Equals(_unknownFields, other._unknownFields); 242 } 243 244 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()245 public override int GetHashCode() { 246 int hash = 1; 247 if (OfferedLoad != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(OfferedLoad); 248 if (_unknownFields != null) { 249 hash ^= _unknownFields.GetHashCode(); 250 } 251 return hash; 252 } 253 254 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()255 public override string ToString() { 256 return pb::JsonFormatter.ToDiagnosticString(this); 257 } 258 259 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)260 public void WriteTo(pb::CodedOutputStream output) { 261 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 262 output.WriteRawMessage(this); 263 #else 264 if (OfferedLoad != 0D) { 265 output.WriteRawTag(9); 266 output.WriteDouble(OfferedLoad); 267 } 268 if (_unknownFields != null) { 269 _unknownFields.WriteTo(output); 270 } 271 #endif 272 } 273 274 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 275 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)276 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 277 if (OfferedLoad != 0D) { 278 output.WriteRawTag(9); 279 output.WriteDouble(OfferedLoad); 280 } 281 if (_unknownFields != null) { 282 _unknownFields.WriteTo(ref output); 283 } 284 } 285 #endif 286 287 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()288 public int CalculateSize() { 289 int size = 0; 290 if (OfferedLoad != 0D) { 291 size += 1 + 8; 292 } 293 if (_unknownFields != null) { 294 size += _unknownFields.CalculateSize(); 295 } 296 return size; 297 } 298 299 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(PoissonParams other)300 public void MergeFrom(PoissonParams other) { 301 if (other == null) { 302 return; 303 } 304 if (other.OfferedLoad != 0D) { 305 OfferedLoad = other.OfferedLoad; 306 } 307 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 308 } 309 310 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)311 public void MergeFrom(pb::CodedInputStream input) { 312 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 313 input.ReadRawMessage(this); 314 #else 315 uint tag; 316 while ((tag = input.ReadTag()) != 0) { 317 switch(tag) { 318 default: 319 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 320 break; 321 case 9: { 322 OfferedLoad = input.ReadDouble(); 323 break; 324 } 325 } 326 } 327 #endif 328 } 329 330 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 331 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)332 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 333 uint tag; 334 while ((tag = input.ReadTag()) != 0) { 335 switch(tag) { 336 default: 337 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 338 break; 339 case 9: { 340 OfferedLoad = input.ReadDouble(); 341 break; 342 } 343 } 344 } 345 } 346 #endif 347 348 } 349 350 /// <summary> 351 /// Once an RPC finishes, immediately start a new one. 352 /// No configuration parameters needed. 353 /// </summary> 354 public sealed partial class ClosedLoopParams : pb::IMessage<ClosedLoopParams> 355 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 356 , pb::IBufferMessage 357 #endif 358 { 359 private static readonly pb::MessageParser<ClosedLoopParams> _parser = new pb::MessageParser<ClosedLoopParams>(() => new ClosedLoopParams()); 360 private pb::UnknownFieldSet _unknownFields; 361 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 362 public static pb::MessageParser<ClosedLoopParams> Parser { get { return _parser; } } 363 364 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 365 public static pbr::MessageDescriptor Descriptor { 366 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[1]; } 367 } 368 369 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 370 pbr::MessageDescriptor pb::IMessage.Descriptor { 371 get { return Descriptor; } 372 } 373 374 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClosedLoopParams()375 public ClosedLoopParams() { 376 OnConstruction(); 377 } 378 OnConstruction()379 partial void OnConstruction(); 380 381 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClosedLoopParams(ClosedLoopParams other)382 public ClosedLoopParams(ClosedLoopParams other) : this() { 383 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 384 } 385 386 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()387 public ClosedLoopParams Clone() { 388 return new ClosedLoopParams(this); 389 } 390 391 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)392 public override bool Equals(object other) { 393 return Equals(other as ClosedLoopParams); 394 } 395 396 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ClosedLoopParams other)397 public bool Equals(ClosedLoopParams other) { 398 if (ReferenceEquals(other, null)) { 399 return false; 400 } 401 if (ReferenceEquals(other, this)) { 402 return true; 403 } 404 return Equals(_unknownFields, other._unknownFields); 405 } 406 407 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()408 public override int GetHashCode() { 409 int hash = 1; 410 if (_unknownFields != null) { 411 hash ^= _unknownFields.GetHashCode(); 412 } 413 return hash; 414 } 415 416 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()417 public override string ToString() { 418 return pb::JsonFormatter.ToDiagnosticString(this); 419 } 420 421 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)422 public void WriteTo(pb::CodedOutputStream output) { 423 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 424 output.WriteRawMessage(this); 425 #else 426 if (_unknownFields != null) { 427 _unknownFields.WriteTo(output); 428 } 429 #endif 430 } 431 432 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 433 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)434 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 435 if (_unknownFields != null) { 436 _unknownFields.WriteTo(ref output); 437 } 438 } 439 #endif 440 441 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()442 public int CalculateSize() { 443 int size = 0; 444 if (_unknownFields != null) { 445 size += _unknownFields.CalculateSize(); 446 } 447 return size; 448 } 449 450 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ClosedLoopParams other)451 public void MergeFrom(ClosedLoopParams other) { 452 if (other == null) { 453 return; 454 } 455 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 456 } 457 458 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)459 public void MergeFrom(pb::CodedInputStream input) { 460 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 461 input.ReadRawMessage(this); 462 #else 463 uint tag; 464 while ((tag = input.ReadTag()) != 0) { 465 switch(tag) { 466 default: 467 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 468 break; 469 } 470 } 471 #endif 472 } 473 474 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 475 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)476 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 477 uint tag; 478 while ((tag = input.ReadTag()) != 0) { 479 switch(tag) { 480 default: 481 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 482 break; 483 } 484 } 485 } 486 #endif 487 488 } 489 490 public sealed partial class LoadParams : pb::IMessage<LoadParams> 491 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 492 , pb::IBufferMessage 493 #endif 494 { 495 private static readonly pb::MessageParser<LoadParams> _parser = new pb::MessageParser<LoadParams>(() => new LoadParams()); 496 private pb::UnknownFieldSet _unknownFields; 497 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 498 public static pb::MessageParser<LoadParams> Parser { get { return _parser; } } 499 500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 501 public static pbr::MessageDescriptor Descriptor { 502 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[2]; } 503 } 504 505 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 506 pbr::MessageDescriptor pb::IMessage.Descriptor { 507 get { return Descriptor; } 508 } 509 510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] LoadParams()511 public LoadParams() { 512 OnConstruction(); 513 } 514 OnConstruction()515 partial void OnConstruction(); 516 517 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] LoadParams(LoadParams other)518 public LoadParams(LoadParams other) : this() { 519 switch (other.LoadCase) { 520 case LoadOneofCase.ClosedLoop: 521 ClosedLoop = other.ClosedLoop.Clone(); 522 break; 523 case LoadOneofCase.Poisson: 524 Poisson = other.Poisson.Clone(); 525 break; 526 } 527 528 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 529 } 530 531 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()532 public LoadParams Clone() { 533 return new LoadParams(this); 534 } 535 536 /// <summary>Field number for the "closed_loop" field.</summary> 537 public const int ClosedLoopFieldNumber = 1; 538 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 539 public global::Grpc.Testing.ClosedLoopParams ClosedLoop { 540 get { return loadCase_ == LoadOneofCase.ClosedLoop ? (global::Grpc.Testing.ClosedLoopParams) load_ : null; } 541 set { 542 load_ = value; 543 loadCase_ = value == null ? LoadOneofCase.None : LoadOneofCase.ClosedLoop; 544 } 545 } 546 547 /// <summary>Field number for the "poisson" field.</summary> 548 public const int PoissonFieldNumber = 2; 549 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 550 public global::Grpc.Testing.PoissonParams Poisson { 551 get { return loadCase_ == LoadOneofCase.Poisson ? (global::Grpc.Testing.PoissonParams) load_ : null; } 552 set { 553 load_ = value; 554 loadCase_ = value == null ? LoadOneofCase.None : LoadOneofCase.Poisson; 555 } 556 } 557 558 private object load_; 559 /// <summary>Enum of possible cases for the "load" oneof.</summary> 560 public enum LoadOneofCase { 561 None = 0, 562 ClosedLoop = 1, 563 Poisson = 2, 564 } 565 private LoadOneofCase loadCase_ = LoadOneofCase.None; 566 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 567 public LoadOneofCase LoadCase { 568 get { return loadCase_; } 569 } 570 571 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClearLoad()572 public void ClearLoad() { 573 loadCase_ = LoadOneofCase.None; 574 load_ = null; 575 } 576 577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)578 public override bool Equals(object other) { 579 return Equals(other as LoadParams); 580 } 581 582 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(LoadParams other)583 public bool Equals(LoadParams other) { 584 if (ReferenceEquals(other, null)) { 585 return false; 586 } 587 if (ReferenceEquals(other, this)) { 588 return true; 589 } 590 if (!object.Equals(ClosedLoop, other.ClosedLoop)) return false; 591 if (!object.Equals(Poisson, other.Poisson)) return false; 592 if (LoadCase != other.LoadCase) return false; 593 return Equals(_unknownFields, other._unknownFields); 594 } 595 596 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()597 public override int GetHashCode() { 598 int hash = 1; 599 if (loadCase_ == LoadOneofCase.ClosedLoop) hash ^= ClosedLoop.GetHashCode(); 600 if (loadCase_ == LoadOneofCase.Poisson) hash ^= Poisson.GetHashCode(); 601 hash ^= (int) loadCase_; 602 if (_unknownFields != null) { 603 hash ^= _unknownFields.GetHashCode(); 604 } 605 return hash; 606 } 607 608 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()609 public override string ToString() { 610 return pb::JsonFormatter.ToDiagnosticString(this); 611 } 612 613 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)614 public void WriteTo(pb::CodedOutputStream output) { 615 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 616 output.WriteRawMessage(this); 617 #else 618 if (loadCase_ == LoadOneofCase.ClosedLoop) { 619 output.WriteRawTag(10); 620 output.WriteMessage(ClosedLoop); 621 } 622 if (loadCase_ == LoadOneofCase.Poisson) { 623 output.WriteRawTag(18); 624 output.WriteMessage(Poisson); 625 } 626 if (_unknownFields != null) { 627 _unknownFields.WriteTo(output); 628 } 629 #endif 630 } 631 632 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 633 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)634 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 635 if (loadCase_ == LoadOneofCase.ClosedLoop) { 636 output.WriteRawTag(10); 637 output.WriteMessage(ClosedLoop); 638 } 639 if (loadCase_ == LoadOneofCase.Poisson) { 640 output.WriteRawTag(18); 641 output.WriteMessage(Poisson); 642 } 643 if (_unknownFields != null) { 644 _unknownFields.WriteTo(ref output); 645 } 646 } 647 #endif 648 649 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()650 public int CalculateSize() { 651 int size = 0; 652 if (loadCase_ == LoadOneofCase.ClosedLoop) { 653 size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClosedLoop); 654 } 655 if (loadCase_ == LoadOneofCase.Poisson) { 656 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Poisson); 657 } 658 if (_unknownFields != null) { 659 size += _unknownFields.CalculateSize(); 660 } 661 return size; 662 } 663 664 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(LoadParams other)665 public void MergeFrom(LoadParams other) { 666 if (other == null) { 667 return; 668 } 669 switch (other.LoadCase) { 670 case LoadOneofCase.ClosedLoop: 671 if (ClosedLoop == null) { 672 ClosedLoop = new global::Grpc.Testing.ClosedLoopParams(); 673 } 674 ClosedLoop.MergeFrom(other.ClosedLoop); 675 break; 676 case LoadOneofCase.Poisson: 677 if (Poisson == null) { 678 Poisson = new global::Grpc.Testing.PoissonParams(); 679 } 680 Poisson.MergeFrom(other.Poisson); 681 break; 682 } 683 684 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 685 } 686 687 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)688 public void MergeFrom(pb::CodedInputStream input) { 689 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 690 input.ReadRawMessage(this); 691 #else 692 uint tag; 693 while ((tag = input.ReadTag()) != 0) { 694 switch(tag) { 695 default: 696 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 697 break; 698 case 10: { 699 global::Grpc.Testing.ClosedLoopParams subBuilder = new global::Grpc.Testing.ClosedLoopParams(); 700 if (loadCase_ == LoadOneofCase.ClosedLoop) { 701 subBuilder.MergeFrom(ClosedLoop); 702 } 703 input.ReadMessage(subBuilder); 704 ClosedLoop = subBuilder; 705 break; 706 } 707 case 18: { 708 global::Grpc.Testing.PoissonParams subBuilder = new global::Grpc.Testing.PoissonParams(); 709 if (loadCase_ == LoadOneofCase.Poisson) { 710 subBuilder.MergeFrom(Poisson); 711 } 712 input.ReadMessage(subBuilder); 713 Poisson = subBuilder; 714 break; 715 } 716 } 717 } 718 #endif 719 } 720 721 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 722 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)723 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 724 uint tag; 725 while ((tag = input.ReadTag()) != 0) { 726 switch(tag) { 727 default: 728 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 729 break; 730 case 10: { 731 global::Grpc.Testing.ClosedLoopParams subBuilder = new global::Grpc.Testing.ClosedLoopParams(); 732 if (loadCase_ == LoadOneofCase.ClosedLoop) { 733 subBuilder.MergeFrom(ClosedLoop); 734 } 735 input.ReadMessage(subBuilder); 736 ClosedLoop = subBuilder; 737 break; 738 } 739 case 18: { 740 global::Grpc.Testing.PoissonParams subBuilder = new global::Grpc.Testing.PoissonParams(); 741 if (loadCase_ == LoadOneofCase.Poisson) { 742 subBuilder.MergeFrom(Poisson); 743 } 744 input.ReadMessage(subBuilder); 745 Poisson = subBuilder; 746 break; 747 } 748 } 749 } 750 } 751 #endif 752 753 } 754 755 /// <summary> 756 /// presence of SecurityParams implies use of TLS 757 /// </summary> 758 public sealed partial class SecurityParams : pb::IMessage<SecurityParams> 759 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 760 , pb::IBufferMessage 761 #endif 762 { 763 private static readonly pb::MessageParser<SecurityParams> _parser = new pb::MessageParser<SecurityParams>(() => new SecurityParams()); 764 private pb::UnknownFieldSet _unknownFields; 765 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 766 public static pb::MessageParser<SecurityParams> Parser { get { return _parser; } } 767 768 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 769 public static pbr::MessageDescriptor Descriptor { 770 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[3]; } 771 } 772 773 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 774 pbr::MessageDescriptor pb::IMessage.Descriptor { 775 get { return Descriptor; } 776 } 777 778 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] SecurityParams()779 public SecurityParams() { 780 OnConstruction(); 781 } 782 OnConstruction()783 partial void OnConstruction(); 784 785 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] SecurityParams(SecurityParams other)786 public SecurityParams(SecurityParams other) : this() { 787 useTestCa_ = other.useTestCa_; 788 serverHostOverride_ = other.serverHostOverride_; 789 credType_ = other.credType_; 790 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 791 } 792 793 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()794 public SecurityParams Clone() { 795 return new SecurityParams(this); 796 } 797 798 /// <summary>Field number for the "use_test_ca" field.</summary> 799 public const int UseTestCaFieldNumber = 1; 800 private bool useTestCa_; 801 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 802 public bool UseTestCa { 803 get { return useTestCa_; } 804 set { 805 useTestCa_ = value; 806 } 807 } 808 809 /// <summary>Field number for the "server_host_override" field.</summary> 810 public const int ServerHostOverrideFieldNumber = 2; 811 private string serverHostOverride_ = ""; 812 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 813 public string ServerHostOverride { 814 get { return serverHostOverride_; } 815 set { 816 serverHostOverride_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 817 } 818 } 819 820 /// <summary>Field number for the "cred_type" field.</summary> 821 public const int CredTypeFieldNumber = 3; 822 private string credType_ = ""; 823 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 824 public string CredType { 825 get { return credType_; } 826 set { 827 credType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 828 } 829 } 830 831 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)832 public override bool Equals(object other) { 833 return Equals(other as SecurityParams); 834 } 835 836 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(SecurityParams other)837 public bool Equals(SecurityParams other) { 838 if (ReferenceEquals(other, null)) { 839 return false; 840 } 841 if (ReferenceEquals(other, this)) { 842 return true; 843 } 844 if (UseTestCa != other.UseTestCa) return false; 845 if (ServerHostOverride != other.ServerHostOverride) return false; 846 if (CredType != other.CredType) return false; 847 return Equals(_unknownFields, other._unknownFields); 848 } 849 850 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()851 public override int GetHashCode() { 852 int hash = 1; 853 if (UseTestCa != false) hash ^= UseTestCa.GetHashCode(); 854 if (ServerHostOverride.Length != 0) hash ^= ServerHostOverride.GetHashCode(); 855 if (CredType.Length != 0) hash ^= CredType.GetHashCode(); 856 if (_unknownFields != null) { 857 hash ^= _unknownFields.GetHashCode(); 858 } 859 return hash; 860 } 861 862 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()863 public override string ToString() { 864 return pb::JsonFormatter.ToDiagnosticString(this); 865 } 866 867 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)868 public void WriteTo(pb::CodedOutputStream output) { 869 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 870 output.WriteRawMessage(this); 871 #else 872 if (UseTestCa != false) { 873 output.WriteRawTag(8); 874 output.WriteBool(UseTestCa); 875 } 876 if (ServerHostOverride.Length != 0) { 877 output.WriteRawTag(18); 878 output.WriteString(ServerHostOverride); 879 } 880 if (CredType.Length != 0) { 881 output.WriteRawTag(26); 882 output.WriteString(CredType); 883 } 884 if (_unknownFields != null) { 885 _unknownFields.WriteTo(output); 886 } 887 #endif 888 } 889 890 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 891 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)892 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 893 if (UseTestCa != false) { 894 output.WriteRawTag(8); 895 output.WriteBool(UseTestCa); 896 } 897 if (ServerHostOverride.Length != 0) { 898 output.WriteRawTag(18); 899 output.WriteString(ServerHostOverride); 900 } 901 if (CredType.Length != 0) { 902 output.WriteRawTag(26); 903 output.WriteString(CredType); 904 } 905 if (_unknownFields != null) { 906 _unknownFields.WriteTo(ref output); 907 } 908 } 909 #endif 910 911 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()912 public int CalculateSize() { 913 int size = 0; 914 if (UseTestCa != false) { 915 size += 1 + 1; 916 } 917 if (ServerHostOverride.Length != 0) { 918 size += 1 + pb::CodedOutputStream.ComputeStringSize(ServerHostOverride); 919 } 920 if (CredType.Length != 0) { 921 size += 1 + pb::CodedOutputStream.ComputeStringSize(CredType); 922 } 923 if (_unknownFields != null) { 924 size += _unknownFields.CalculateSize(); 925 } 926 return size; 927 } 928 929 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(SecurityParams other)930 public void MergeFrom(SecurityParams other) { 931 if (other == null) { 932 return; 933 } 934 if (other.UseTestCa != false) { 935 UseTestCa = other.UseTestCa; 936 } 937 if (other.ServerHostOverride.Length != 0) { 938 ServerHostOverride = other.ServerHostOverride; 939 } 940 if (other.CredType.Length != 0) { 941 CredType = other.CredType; 942 } 943 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 944 } 945 946 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)947 public void MergeFrom(pb::CodedInputStream input) { 948 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 949 input.ReadRawMessage(this); 950 #else 951 uint tag; 952 while ((tag = input.ReadTag()) != 0) { 953 switch(tag) { 954 default: 955 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 956 break; 957 case 8: { 958 UseTestCa = input.ReadBool(); 959 break; 960 } 961 case 18: { 962 ServerHostOverride = input.ReadString(); 963 break; 964 } 965 case 26: { 966 CredType = input.ReadString(); 967 break; 968 } 969 } 970 } 971 #endif 972 } 973 974 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 975 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)976 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 977 uint tag; 978 while ((tag = input.ReadTag()) != 0) { 979 switch(tag) { 980 default: 981 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 982 break; 983 case 8: { 984 UseTestCa = input.ReadBool(); 985 break; 986 } 987 case 18: { 988 ServerHostOverride = input.ReadString(); 989 break; 990 } 991 case 26: { 992 CredType = input.ReadString(); 993 break; 994 } 995 } 996 } 997 } 998 #endif 999 1000 } 1001 1002 public sealed partial class ChannelArg : pb::IMessage<ChannelArg> 1003 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 1004 , pb::IBufferMessage 1005 #endif 1006 { 1007 private static readonly pb::MessageParser<ChannelArg> _parser = new pb::MessageParser<ChannelArg>(() => new ChannelArg()); 1008 private pb::UnknownFieldSet _unknownFields; 1009 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1010 public static pb::MessageParser<ChannelArg> Parser { get { return _parser; } } 1011 1012 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1013 public static pbr::MessageDescriptor Descriptor { 1014 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[4]; } 1015 } 1016 1017 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1018 pbr::MessageDescriptor pb::IMessage.Descriptor { 1019 get { return Descriptor; } 1020 } 1021 1022 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ChannelArg()1023 public ChannelArg() { 1024 OnConstruction(); 1025 } 1026 OnConstruction()1027 partial void OnConstruction(); 1028 1029 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ChannelArg(ChannelArg other)1030 public ChannelArg(ChannelArg other) : this() { 1031 name_ = other.name_; 1032 switch (other.ValueCase) { 1033 case ValueOneofCase.StrValue: 1034 StrValue = other.StrValue; 1035 break; 1036 case ValueOneofCase.IntValue: 1037 IntValue = other.IntValue; 1038 break; 1039 } 1040 1041 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 1042 } 1043 1044 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()1045 public ChannelArg Clone() { 1046 return new ChannelArg(this); 1047 } 1048 1049 /// <summary>Field number for the "name" field.</summary> 1050 public const int NameFieldNumber = 1; 1051 private string name_ = ""; 1052 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1053 public string Name { 1054 get { return name_; } 1055 set { 1056 name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 1057 } 1058 } 1059 1060 /// <summary>Field number for the "str_value" field.</summary> 1061 public const int StrValueFieldNumber = 2; 1062 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1063 public string StrValue { 1064 get { return valueCase_ == ValueOneofCase.StrValue ? (string) value_ : ""; } 1065 set { 1066 value_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 1067 valueCase_ = ValueOneofCase.StrValue; 1068 } 1069 } 1070 1071 /// <summary>Field number for the "int_value" field.</summary> 1072 public const int IntValueFieldNumber = 3; 1073 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1074 public int IntValue { 1075 get { return valueCase_ == ValueOneofCase.IntValue ? (int) value_ : 0; } 1076 set { 1077 value_ = value; 1078 valueCase_ = ValueOneofCase.IntValue; 1079 } 1080 } 1081 1082 private object value_; 1083 /// <summary>Enum of possible cases for the "value" oneof.</summary> 1084 public enum ValueOneofCase { 1085 None = 0, 1086 StrValue = 2, 1087 IntValue = 3, 1088 } 1089 private ValueOneofCase valueCase_ = ValueOneofCase.None; 1090 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1091 public ValueOneofCase ValueCase { 1092 get { return valueCase_; } 1093 } 1094 1095 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClearValue()1096 public void ClearValue() { 1097 valueCase_ = ValueOneofCase.None; 1098 value_ = null; 1099 } 1100 1101 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)1102 public override bool Equals(object other) { 1103 return Equals(other as ChannelArg); 1104 } 1105 1106 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ChannelArg other)1107 public bool Equals(ChannelArg other) { 1108 if (ReferenceEquals(other, null)) { 1109 return false; 1110 } 1111 if (ReferenceEquals(other, this)) { 1112 return true; 1113 } 1114 if (Name != other.Name) return false; 1115 if (StrValue != other.StrValue) return false; 1116 if (IntValue != other.IntValue) return false; 1117 if (ValueCase != other.ValueCase) return false; 1118 return Equals(_unknownFields, other._unknownFields); 1119 } 1120 1121 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()1122 public override int GetHashCode() { 1123 int hash = 1; 1124 if (Name.Length != 0) hash ^= Name.GetHashCode(); 1125 if (valueCase_ == ValueOneofCase.StrValue) hash ^= StrValue.GetHashCode(); 1126 if (valueCase_ == ValueOneofCase.IntValue) hash ^= IntValue.GetHashCode(); 1127 hash ^= (int) valueCase_; 1128 if (_unknownFields != null) { 1129 hash ^= _unknownFields.GetHashCode(); 1130 } 1131 return hash; 1132 } 1133 1134 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()1135 public override string ToString() { 1136 return pb::JsonFormatter.ToDiagnosticString(this); 1137 } 1138 1139 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)1140 public void WriteTo(pb::CodedOutputStream output) { 1141 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 1142 output.WriteRawMessage(this); 1143 #else 1144 if (Name.Length != 0) { 1145 output.WriteRawTag(10); 1146 output.WriteString(Name); 1147 } 1148 if (valueCase_ == ValueOneofCase.StrValue) { 1149 output.WriteRawTag(18); 1150 output.WriteString(StrValue); 1151 } 1152 if (valueCase_ == ValueOneofCase.IntValue) { 1153 output.WriteRawTag(24); 1154 output.WriteInt32(IntValue); 1155 } 1156 if (_unknownFields != null) { 1157 _unknownFields.WriteTo(output); 1158 } 1159 #endif 1160 } 1161 1162 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 1163 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)1164 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 1165 if (Name.Length != 0) { 1166 output.WriteRawTag(10); 1167 output.WriteString(Name); 1168 } 1169 if (valueCase_ == ValueOneofCase.StrValue) { 1170 output.WriteRawTag(18); 1171 output.WriteString(StrValue); 1172 } 1173 if (valueCase_ == ValueOneofCase.IntValue) { 1174 output.WriteRawTag(24); 1175 output.WriteInt32(IntValue); 1176 } 1177 if (_unknownFields != null) { 1178 _unknownFields.WriteTo(ref output); 1179 } 1180 } 1181 #endif 1182 1183 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()1184 public int CalculateSize() { 1185 int size = 0; 1186 if (Name.Length != 0) { 1187 size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); 1188 } 1189 if (valueCase_ == ValueOneofCase.StrValue) { 1190 size += 1 + pb::CodedOutputStream.ComputeStringSize(StrValue); 1191 } 1192 if (valueCase_ == ValueOneofCase.IntValue) { 1193 size += 1 + pb::CodedOutputStream.ComputeInt32Size(IntValue); 1194 } 1195 if (_unknownFields != null) { 1196 size += _unknownFields.CalculateSize(); 1197 } 1198 return size; 1199 } 1200 1201 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ChannelArg other)1202 public void MergeFrom(ChannelArg other) { 1203 if (other == null) { 1204 return; 1205 } 1206 if (other.Name.Length != 0) { 1207 Name = other.Name; 1208 } 1209 switch (other.ValueCase) { 1210 case ValueOneofCase.StrValue: 1211 StrValue = other.StrValue; 1212 break; 1213 case ValueOneofCase.IntValue: 1214 IntValue = other.IntValue; 1215 break; 1216 } 1217 1218 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 1219 } 1220 1221 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)1222 public void MergeFrom(pb::CodedInputStream input) { 1223 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 1224 input.ReadRawMessage(this); 1225 #else 1226 uint tag; 1227 while ((tag = input.ReadTag()) != 0) { 1228 switch(tag) { 1229 default: 1230 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 1231 break; 1232 case 10: { 1233 Name = input.ReadString(); 1234 break; 1235 } 1236 case 18: { 1237 StrValue = input.ReadString(); 1238 break; 1239 } 1240 case 24: { 1241 IntValue = input.ReadInt32(); 1242 break; 1243 } 1244 } 1245 } 1246 #endif 1247 } 1248 1249 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 1250 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)1251 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 1252 uint tag; 1253 while ((tag = input.ReadTag()) != 0) { 1254 switch(tag) { 1255 default: 1256 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 1257 break; 1258 case 10: { 1259 Name = input.ReadString(); 1260 break; 1261 } 1262 case 18: { 1263 StrValue = input.ReadString(); 1264 break; 1265 } 1266 case 24: { 1267 IntValue = input.ReadInt32(); 1268 break; 1269 } 1270 } 1271 } 1272 } 1273 #endif 1274 1275 } 1276 1277 public sealed partial class ClientConfig : pb::IMessage<ClientConfig> 1278 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 1279 , pb::IBufferMessage 1280 #endif 1281 { 1282 private static readonly pb::MessageParser<ClientConfig> _parser = new pb::MessageParser<ClientConfig>(() => new ClientConfig()); 1283 private pb::UnknownFieldSet _unknownFields; 1284 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1285 public static pb::MessageParser<ClientConfig> Parser { get { return _parser; } } 1286 1287 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1288 public static pbr::MessageDescriptor Descriptor { 1289 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[5]; } 1290 } 1291 1292 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1293 pbr::MessageDescriptor pb::IMessage.Descriptor { 1294 get { return Descriptor; } 1295 } 1296 1297 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientConfig()1298 public ClientConfig() { 1299 OnConstruction(); 1300 } 1301 OnConstruction()1302 partial void OnConstruction(); 1303 1304 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientConfig(ClientConfig other)1305 public ClientConfig(ClientConfig other) : this() { 1306 serverTargets_ = other.serverTargets_.Clone(); 1307 clientType_ = other.clientType_; 1308 securityParams_ = other.securityParams_ != null ? other.securityParams_.Clone() : null; 1309 outstandingRpcsPerChannel_ = other.outstandingRpcsPerChannel_; 1310 clientChannels_ = other.clientChannels_; 1311 asyncClientThreads_ = other.asyncClientThreads_; 1312 rpcType_ = other.rpcType_; 1313 loadParams_ = other.loadParams_ != null ? other.loadParams_.Clone() : null; 1314 payloadConfig_ = other.payloadConfig_ != null ? other.payloadConfig_.Clone() : null; 1315 histogramParams_ = other.histogramParams_ != null ? other.histogramParams_.Clone() : null; 1316 coreList_ = other.coreList_.Clone(); 1317 coreLimit_ = other.coreLimit_; 1318 otherClientApi_ = other.otherClientApi_; 1319 channelArgs_ = other.channelArgs_.Clone(); 1320 threadsPerCq_ = other.threadsPerCq_; 1321 messagesPerStream_ = other.messagesPerStream_; 1322 useCoalesceApi_ = other.useCoalesceApi_; 1323 medianLatencyCollectionIntervalMillis_ = other.medianLatencyCollectionIntervalMillis_; 1324 clientProcesses_ = other.clientProcesses_; 1325 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 1326 } 1327 1328 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()1329 public ClientConfig Clone() { 1330 return new ClientConfig(this); 1331 } 1332 1333 /// <summary>Field number for the "server_targets" field.</summary> 1334 public const int ServerTargetsFieldNumber = 1; 1335 private static readonly pb::FieldCodec<string> _repeated_serverTargets_codec 1336 = pb::FieldCodec.ForString(10); 1337 private readonly pbc::RepeatedField<string> serverTargets_ = new pbc::RepeatedField<string>(); 1338 /// <summary> 1339 /// List of targets to connect to. At least one target needs to be specified. 1340 /// </summary> 1341 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1342 public pbc::RepeatedField<string> ServerTargets { 1343 get { return serverTargets_; } 1344 } 1345 1346 /// <summary>Field number for the "client_type" field.</summary> 1347 public const int ClientTypeFieldNumber = 2; 1348 private global::Grpc.Testing.ClientType clientType_ = global::Grpc.Testing.ClientType.SyncClient; 1349 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1350 public global::Grpc.Testing.ClientType ClientType { 1351 get { return clientType_; } 1352 set { 1353 clientType_ = value; 1354 } 1355 } 1356 1357 /// <summary>Field number for the "security_params" field.</summary> 1358 public const int SecurityParamsFieldNumber = 3; 1359 private global::Grpc.Testing.SecurityParams securityParams_; 1360 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1361 public global::Grpc.Testing.SecurityParams SecurityParams { 1362 get { return securityParams_; } 1363 set { 1364 securityParams_ = value; 1365 } 1366 } 1367 1368 /// <summary>Field number for the "outstanding_rpcs_per_channel" field.</summary> 1369 public const int OutstandingRpcsPerChannelFieldNumber = 4; 1370 private int outstandingRpcsPerChannel_; 1371 /// <summary> 1372 /// How many concurrent RPCs to start for each channel. 1373 /// For synchronous client, use a separate thread for each outstanding RPC. 1374 /// </summary> 1375 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1376 public int OutstandingRpcsPerChannel { 1377 get { return outstandingRpcsPerChannel_; } 1378 set { 1379 outstandingRpcsPerChannel_ = value; 1380 } 1381 } 1382 1383 /// <summary>Field number for the "client_channels" field.</summary> 1384 public const int ClientChannelsFieldNumber = 5; 1385 private int clientChannels_; 1386 /// <summary> 1387 /// Number of independent client channels to create. 1388 /// i-th channel will connect to server_target[i % server_targets.size()] 1389 /// </summary> 1390 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1391 public int ClientChannels { 1392 get { return clientChannels_; } 1393 set { 1394 clientChannels_ = value; 1395 } 1396 } 1397 1398 /// <summary>Field number for the "async_client_threads" field.</summary> 1399 public const int AsyncClientThreadsFieldNumber = 7; 1400 private int asyncClientThreads_; 1401 /// <summary> 1402 /// Only for async client. Number of threads to use to start/manage RPCs. 1403 /// </summary> 1404 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1405 public int AsyncClientThreads { 1406 get { return asyncClientThreads_; } 1407 set { 1408 asyncClientThreads_ = value; 1409 } 1410 } 1411 1412 /// <summary>Field number for the "rpc_type" field.</summary> 1413 public const int RpcTypeFieldNumber = 8; 1414 private global::Grpc.Testing.RpcType rpcType_ = global::Grpc.Testing.RpcType.Unary; 1415 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1416 public global::Grpc.Testing.RpcType RpcType { 1417 get { return rpcType_; } 1418 set { 1419 rpcType_ = value; 1420 } 1421 } 1422 1423 /// <summary>Field number for the "load_params" field.</summary> 1424 public const int LoadParamsFieldNumber = 10; 1425 private global::Grpc.Testing.LoadParams loadParams_; 1426 /// <summary> 1427 /// The requested load for the entire client (aggregated over all the threads). 1428 /// </summary> 1429 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1430 public global::Grpc.Testing.LoadParams LoadParams { 1431 get { return loadParams_; } 1432 set { 1433 loadParams_ = value; 1434 } 1435 } 1436 1437 /// <summary>Field number for the "payload_config" field.</summary> 1438 public const int PayloadConfigFieldNumber = 11; 1439 private global::Grpc.Testing.PayloadConfig payloadConfig_; 1440 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1441 public global::Grpc.Testing.PayloadConfig PayloadConfig { 1442 get { return payloadConfig_; } 1443 set { 1444 payloadConfig_ = value; 1445 } 1446 } 1447 1448 /// <summary>Field number for the "histogram_params" field.</summary> 1449 public const int HistogramParamsFieldNumber = 12; 1450 private global::Grpc.Testing.HistogramParams histogramParams_; 1451 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1452 public global::Grpc.Testing.HistogramParams HistogramParams { 1453 get { return histogramParams_; } 1454 set { 1455 histogramParams_ = value; 1456 } 1457 } 1458 1459 /// <summary>Field number for the "core_list" field.</summary> 1460 public const int CoreListFieldNumber = 13; 1461 private static readonly pb::FieldCodec<int> _repeated_coreList_codec 1462 = pb::FieldCodec.ForInt32(106); 1463 private readonly pbc::RepeatedField<int> coreList_ = new pbc::RepeatedField<int>(); 1464 /// <summary> 1465 /// Specify the cores we should run the client on, if desired 1466 /// </summary> 1467 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1468 public pbc::RepeatedField<int> CoreList { 1469 get { return coreList_; } 1470 } 1471 1472 /// <summary>Field number for the "core_limit" field.</summary> 1473 public const int CoreLimitFieldNumber = 14; 1474 private int coreLimit_; 1475 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1476 public int CoreLimit { 1477 get { return coreLimit_; } 1478 set { 1479 coreLimit_ = value; 1480 } 1481 } 1482 1483 /// <summary>Field number for the "other_client_api" field.</summary> 1484 public const int OtherClientApiFieldNumber = 15; 1485 private string otherClientApi_ = ""; 1486 /// <summary> 1487 /// If we use an OTHER_CLIENT client_type, this string gives more detail 1488 /// </summary> 1489 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1490 public string OtherClientApi { 1491 get { return otherClientApi_; } 1492 set { 1493 otherClientApi_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 1494 } 1495 } 1496 1497 /// <summary>Field number for the "channel_args" field.</summary> 1498 public const int ChannelArgsFieldNumber = 16; 1499 private static readonly pb::FieldCodec<global::Grpc.Testing.ChannelArg> _repeated_channelArgs_codec 1500 = pb::FieldCodec.ForMessage(130, global::Grpc.Testing.ChannelArg.Parser); 1501 private readonly pbc::RepeatedField<global::Grpc.Testing.ChannelArg> channelArgs_ = new pbc::RepeatedField<global::Grpc.Testing.ChannelArg>(); 1502 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1503 public pbc::RepeatedField<global::Grpc.Testing.ChannelArg> ChannelArgs { 1504 get { return channelArgs_; } 1505 } 1506 1507 /// <summary>Field number for the "threads_per_cq" field.</summary> 1508 public const int ThreadsPerCqFieldNumber = 17; 1509 private int threadsPerCq_; 1510 /// <summary> 1511 /// Number of threads that share each completion queue 1512 /// </summary> 1513 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1514 public int ThreadsPerCq { 1515 get { return threadsPerCq_; } 1516 set { 1517 threadsPerCq_ = value; 1518 } 1519 } 1520 1521 /// <summary>Field number for the "messages_per_stream" field.</summary> 1522 public const int MessagesPerStreamFieldNumber = 18; 1523 private int messagesPerStream_; 1524 /// <summary> 1525 /// Number of messages on a stream before it gets finished/restarted 1526 /// </summary> 1527 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1528 public int MessagesPerStream { 1529 get { return messagesPerStream_; } 1530 set { 1531 messagesPerStream_ = value; 1532 } 1533 } 1534 1535 /// <summary>Field number for the "use_coalesce_api" field.</summary> 1536 public const int UseCoalesceApiFieldNumber = 19; 1537 private bool useCoalesceApi_; 1538 /// <summary> 1539 /// Use coalescing API when possible. 1540 /// </summary> 1541 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1542 public bool UseCoalesceApi { 1543 get { return useCoalesceApi_; } 1544 set { 1545 useCoalesceApi_ = value; 1546 } 1547 } 1548 1549 /// <summary>Field number for the "median_latency_collection_interval_millis" field.</summary> 1550 public const int MedianLatencyCollectionIntervalMillisFieldNumber = 20; 1551 private int medianLatencyCollectionIntervalMillis_; 1552 /// <summary> 1553 /// If 0, disabled. Else, specifies the period between gathering latency 1554 /// medians in milliseconds. 1555 /// </summary> 1556 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1557 public int MedianLatencyCollectionIntervalMillis { 1558 get { return medianLatencyCollectionIntervalMillis_; } 1559 set { 1560 medianLatencyCollectionIntervalMillis_ = value; 1561 } 1562 } 1563 1564 /// <summary>Field number for the "client_processes" field.</summary> 1565 public const int ClientProcessesFieldNumber = 21; 1566 private int clientProcesses_; 1567 /// <summary> 1568 /// Number of client processes. 0 indicates no restriction. 1569 /// </summary> 1570 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1571 public int ClientProcesses { 1572 get { return clientProcesses_; } 1573 set { 1574 clientProcesses_ = value; 1575 } 1576 } 1577 1578 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)1579 public override bool Equals(object other) { 1580 return Equals(other as ClientConfig); 1581 } 1582 1583 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ClientConfig other)1584 public bool Equals(ClientConfig other) { 1585 if (ReferenceEquals(other, null)) { 1586 return false; 1587 } 1588 if (ReferenceEquals(other, this)) { 1589 return true; 1590 } 1591 if(!serverTargets_.Equals(other.serverTargets_)) return false; 1592 if (ClientType != other.ClientType) return false; 1593 if (!object.Equals(SecurityParams, other.SecurityParams)) return false; 1594 if (OutstandingRpcsPerChannel != other.OutstandingRpcsPerChannel) return false; 1595 if (ClientChannels != other.ClientChannels) return false; 1596 if (AsyncClientThreads != other.AsyncClientThreads) return false; 1597 if (RpcType != other.RpcType) return false; 1598 if (!object.Equals(LoadParams, other.LoadParams)) return false; 1599 if (!object.Equals(PayloadConfig, other.PayloadConfig)) return false; 1600 if (!object.Equals(HistogramParams, other.HistogramParams)) return false; 1601 if(!coreList_.Equals(other.coreList_)) return false; 1602 if (CoreLimit != other.CoreLimit) return false; 1603 if (OtherClientApi != other.OtherClientApi) return false; 1604 if(!channelArgs_.Equals(other.channelArgs_)) return false; 1605 if (ThreadsPerCq != other.ThreadsPerCq) return false; 1606 if (MessagesPerStream != other.MessagesPerStream) return false; 1607 if (UseCoalesceApi != other.UseCoalesceApi) return false; 1608 if (MedianLatencyCollectionIntervalMillis != other.MedianLatencyCollectionIntervalMillis) return false; 1609 if (ClientProcesses != other.ClientProcesses) return false; 1610 return Equals(_unknownFields, other._unknownFields); 1611 } 1612 1613 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()1614 public override int GetHashCode() { 1615 int hash = 1; 1616 hash ^= serverTargets_.GetHashCode(); 1617 if (ClientType != global::Grpc.Testing.ClientType.SyncClient) hash ^= ClientType.GetHashCode(); 1618 if (securityParams_ != null) hash ^= SecurityParams.GetHashCode(); 1619 if (OutstandingRpcsPerChannel != 0) hash ^= OutstandingRpcsPerChannel.GetHashCode(); 1620 if (ClientChannels != 0) hash ^= ClientChannels.GetHashCode(); 1621 if (AsyncClientThreads != 0) hash ^= AsyncClientThreads.GetHashCode(); 1622 if (RpcType != global::Grpc.Testing.RpcType.Unary) hash ^= RpcType.GetHashCode(); 1623 if (loadParams_ != null) hash ^= LoadParams.GetHashCode(); 1624 if (payloadConfig_ != null) hash ^= PayloadConfig.GetHashCode(); 1625 if (histogramParams_ != null) hash ^= HistogramParams.GetHashCode(); 1626 hash ^= coreList_.GetHashCode(); 1627 if (CoreLimit != 0) hash ^= CoreLimit.GetHashCode(); 1628 if (OtherClientApi.Length != 0) hash ^= OtherClientApi.GetHashCode(); 1629 hash ^= channelArgs_.GetHashCode(); 1630 if (ThreadsPerCq != 0) hash ^= ThreadsPerCq.GetHashCode(); 1631 if (MessagesPerStream != 0) hash ^= MessagesPerStream.GetHashCode(); 1632 if (UseCoalesceApi != false) hash ^= UseCoalesceApi.GetHashCode(); 1633 if (MedianLatencyCollectionIntervalMillis != 0) hash ^= MedianLatencyCollectionIntervalMillis.GetHashCode(); 1634 if (ClientProcesses != 0) hash ^= ClientProcesses.GetHashCode(); 1635 if (_unknownFields != null) { 1636 hash ^= _unknownFields.GetHashCode(); 1637 } 1638 return hash; 1639 } 1640 1641 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()1642 public override string ToString() { 1643 return pb::JsonFormatter.ToDiagnosticString(this); 1644 } 1645 1646 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)1647 public void WriteTo(pb::CodedOutputStream output) { 1648 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 1649 output.WriteRawMessage(this); 1650 #else 1651 serverTargets_.WriteTo(output, _repeated_serverTargets_codec); 1652 if (ClientType != global::Grpc.Testing.ClientType.SyncClient) { 1653 output.WriteRawTag(16); 1654 output.WriteEnum((int) ClientType); 1655 } 1656 if (securityParams_ != null) { 1657 output.WriteRawTag(26); 1658 output.WriteMessage(SecurityParams); 1659 } 1660 if (OutstandingRpcsPerChannel != 0) { 1661 output.WriteRawTag(32); 1662 output.WriteInt32(OutstandingRpcsPerChannel); 1663 } 1664 if (ClientChannels != 0) { 1665 output.WriteRawTag(40); 1666 output.WriteInt32(ClientChannels); 1667 } 1668 if (AsyncClientThreads != 0) { 1669 output.WriteRawTag(56); 1670 output.WriteInt32(AsyncClientThreads); 1671 } 1672 if (RpcType != global::Grpc.Testing.RpcType.Unary) { 1673 output.WriteRawTag(64); 1674 output.WriteEnum((int) RpcType); 1675 } 1676 if (loadParams_ != null) { 1677 output.WriteRawTag(82); 1678 output.WriteMessage(LoadParams); 1679 } 1680 if (payloadConfig_ != null) { 1681 output.WriteRawTag(90); 1682 output.WriteMessage(PayloadConfig); 1683 } 1684 if (histogramParams_ != null) { 1685 output.WriteRawTag(98); 1686 output.WriteMessage(HistogramParams); 1687 } 1688 coreList_.WriteTo(output, _repeated_coreList_codec); 1689 if (CoreLimit != 0) { 1690 output.WriteRawTag(112); 1691 output.WriteInt32(CoreLimit); 1692 } 1693 if (OtherClientApi.Length != 0) { 1694 output.WriteRawTag(122); 1695 output.WriteString(OtherClientApi); 1696 } 1697 channelArgs_.WriteTo(output, _repeated_channelArgs_codec); 1698 if (ThreadsPerCq != 0) { 1699 output.WriteRawTag(136, 1); 1700 output.WriteInt32(ThreadsPerCq); 1701 } 1702 if (MessagesPerStream != 0) { 1703 output.WriteRawTag(144, 1); 1704 output.WriteInt32(MessagesPerStream); 1705 } 1706 if (UseCoalesceApi != false) { 1707 output.WriteRawTag(152, 1); 1708 output.WriteBool(UseCoalesceApi); 1709 } 1710 if (MedianLatencyCollectionIntervalMillis != 0) { 1711 output.WriteRawTag(160, 1); 1712 output.WriteInt32(MedianLatencyCollectionIntervalMillis); 1713 } 1714 if (ClientProcesses != 0) { 1715 output.WriteRawTag(168, 1); 1716 output.WriteInt32(ClientProcesses); 1717 } 1718 if (_unknownFields != null) { 1719 _unknownFields.WriteTo(output); 1720 } 1721 #endif 1722 } 1723 1724 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 1725 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)1726 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 1727 serverTargets_.WriteTo(ref output, _repeated_serverTargets_codec); 1728 if (ClientType != global::Grpc.Testing.ClientType.SyncClient) { 1729 output.WriteRawTag(16); 1730 output.WriteEnum((int) ClientType); 1731 } 1732 if (securityParams_ != null) { 1733 output.WriteRawTag(26); 1734 output.WriteMessage(SecurityParams); 1735 } 1736 if (OutstandingRpcsPerChannel != 0) { 1737 output.WriteRawTag(32); 1738 output.WriteInt32(OutstandingRpcsPerChannel); 1739 } 1740 if (ClientChannels != 0) { 1741 output.WriteRawTag(40); 1742 output.WriteInt32(ClientChannels); 1743 } 1744 if (AsyncClientThreads != 0) { 1745 output.WriteRawTag(56); 1746 output.WriteInt32(AsyncClientThreads); 1747 } 1748 if (RpcType != global::Grpc.Testing.RpcType.Unary) { 1749 output.WriteRawTag(64); 1750 output.WriteEnum((int) RpcType); 1751 } 1752 if (loadParams_ != null) { 1753 output.WriteRawTag(82); 1754 output.WriteMessage(LoadParams); 1755 } 1756 if (payloadConfig_ != null) { 1757 output.WriteRawTag(90); 1758 output.WriteMessage(PayloadConfig); 1759 } 1760 if (histogramParams_ != null) { 1761 output.WriteRawTag(98); 1762 output.WriteMessage(HistogramParams); 1763 } 1764 coreList_.WriteTo(ref output, _repeated_coreList_codec); 1765 if (CoreLimit != 0) { 1766 output.WriteRawTag(112); 1767 output.WriteInt32(CoreLimit); 1768 } 1769 if (OtherClientApi.Length != 0) { 1770 output.WriteRawTag(122); 1771 output.WriteString(OtherClientApi); 1772 } 1773 channelArgs_.WriteTo(ref output, _repeated_channelArgs_codec); 1774 if (ThreadsPerCq != 0) { 1775 output.WriteRawTag(136, 1); 1776 output.WriteInt32(ThreadsPerCq); 1777 } 1778 if (MessagesPerStream != 0) { 1779 output.WriteRawTag(144, 1); 1780 output.WriteInt32(MessagesPerStream); 1781 } 1782 if (UseCoalesceApi != false) { 1783 output.WriteRawTag(152, 1); 1784 output.WriteBool(UseCoalesceApi); 1785 } 1786 if (MedianLatencyCollectionIntervalMillis != 0) { 1787 output.WriteRawTag(160, 1); 1788 output.WriteInt32(MedianLatencyCollectionIntervalMillis); 1789 } 1790 if (ClientProcesses != 0) { 1791 output.WriteRawTag(168, 1); 1792 output.WriteInt32(ClientProcesses); 1793 } 1794 if (_unknownFields != null) { 1795 _unknownFields.WriteTo(ref output); 1796 } 1797 } 1798 #endif 1799 1800 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()1801 public int CalculateSize() { 1802 int size = 0; 1803 size += serverTargets_.CalculateSize(_repeated_serverTargets_codec); 1804 if (ClientType != global::Grpc.Testing.ClientType.SyncClient) { 1805 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) ClientType); 1806 } 1807 if (securityParams_ != null) { 1808 size += 1 + pb::CodedOutputStream.ComputeMessageSize(SecurityParams); 1809 } 1810 if (OutstandingRpcsPerChannel != 0) { 1811 size += 1 + pb::CodedOutputStream.ComputeInt32Size(OutstandingRpcsPerChannel); 1812 } 1813 if (ClientChannels != 0) { 1814 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClientChannels); 1815 } 1816 if (AsyncClientThreads != 0) { 1817 size += 1 + pb::CodedOutputStream.ComputeInt32Size(AsyncClientThreads); 1818 } 1819 if (RpcType != global::Grpc.Testing.RpcType.Unary) { 1820 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) RpcType); 1821 } 1822 if (loadParams_ != null) { 1823 size += 1 + pb::CodedOutputStream.ComputeMessageSize(LoadParams); 1824 } 1825 if (payloadConfig_ != null) { 1826 size += 1 + pb::CodedOutputStream.ComputeMessageSize(PayloadConfig); 1827 } 1828 if (histogramParams_ != null) { 1829 size += 1 + pb::CodedOutputStream.ComputeMessageSize(HistogramParams); 1830 } 1831 size += coreList_.CalculateSize(_repeated_coreList_codec); 1832 if (CoreLimit != 0) { 1833 size += 1 + pb::CodedOutputStream.ComputeInt32Size(CoreLimit); 1834 } 1835 if (OtherClientApi.Length != 0) { 1836 size += 1 + pb::CodedOutputStream.ComputeStringSize(OtherClientApi); 1837 } 1838 size += channelArgs_.CalculateSize(_repeated_channelArgs_codec); 1839 if (ThreadsPerCq != 0) { 1840 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ThreadsPerCq); 1841 } 1842 if (MessagesPerStream != 0) { 1843 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MessagesPerStream); 1844 } 1845 if (UseCoalesceApi != false) { 1846 size += 2 + 1; 1847 } 1848 if (MedianLatencyCollectionIntervalMillis != 0) { 1849 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MedianLatencyCollectionIntervalMillis); 1850 } 1851 if (ClientProcesses != 0) { 1852 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ClientProcesses); 1853 } 1854 if (_unknownFields != null) { 1855 size += _unknownFields.CalculateSize(); 1856 } 1857 return size; 1858 } 1859 1860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ClientConfig other)1861 public void MergeFrom(ClientConfig other) { 1862 if (other == null) { 1863 return; 1864 } 1865 serverTargets_.Add(other.serverTargets_); 1866 if (other.ClientType != global::Grpc.Testing.ClientType.SyncClient) { 1867 ClientType = other.ClientType; 1868 } 1869 if (other.securityParams_ != null) { 1870 if (securityParams_ == null) { 1871 SecurityParams = new global::Grpc.Testing.SecurityParams(); 1872 } 1873 SecurityParams.MergeFrom(other.SecurityParams); 1874 } 1875 if (other.OutstandingRpcsPerChannel != 0) { 1876 OutstandingRpcsPerChannel = other.OutstandingRpcsPerChannel; 1877 } 1878 if (other.ClientChannels != 0) { 1879 ClientChannels = other.ClientChannels; 1880 } 1881 if (other.AsyncClientThreads != 0) { 1882 AsyncClientThreads = other.AsyncClientThreads; 1883 } 1884 if (other.RpcType != global::Grpc.Testing.RpcType.Unary) { 1885 RpcType = other.RpcType; 1886 } 1887 if (other.loadParams_ != null) { 1888 if (loadParams_ == null) { 1889 LoadParams = new global::Grpc.Testing.LoadParams(); 1890 } 1891 LoadParams.MergeFrom(other.LoadParams); 1892 } 1893 if (other.payloadConfig_ != null) { 1894 if (payloadConfig_ == null) { 1895 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 1896 } 1897 PayloadConfig.MergeFrom(other.PayloadConfig); 1898 } 1899 if (other.histogramParams_ != null) { 1900 if (histogramParams_ == null) { 1901 HistogramParams = new global::Grpc.Testing.HistogramParams(); 1902 } 1903 HistogramParams.MergeFrom(other.HistogramParams); 1904 } 1905 coreList_.Add(other.coreList_); 1906 if (other.CoreLimit != 0) { 1907 CoreLimit = other.CoreLimit; 1908 } 1909 if (other.OtherClientApi.Length != 0) { 1910 OtherClientApi = other.OtherClientApi; 1911 } 1912 channelArgs_.Add(other.channelArgs_); 1913 if (other.ThreadsPerCq != 0) { 1914 ThreadsPerCq = other.ThreadsPerCq; 1915 } 1916 if (other.MessagesPerStream != 0) { 1917 MessagesPerStream = other.MessagesPerStream; 1918 } 1919 if (other.UseCoalesceApi != false) { 1920 UseCoalesceApi = other.UseCoalesceApi; 1921 } 1922 if (other.MedianLatencyCollectionIntervalMillis != 0) { 1923 MedianLatencyCollectionIntervalMillis = other.MedianLatencyCollectionIntervalMillis; 1924 } 1925 if (other.ClientProcesses != 0) { 1926 ClientProcesses = other.ClientProcesses; 1927 } 1928 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 1929 } 1930 1931 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)1932 public void MergeFrom(pb::CodedInputStream input) { 1933 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 1934 input.ReadRawMessage(this); 1935 #else 1936 uint tag; 1937 while ((tag = input.ReadTag()) != 0) { 1938 switch(tag) { 1939 default: 1940 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 1941 break; 1942 case 10: { 1943 serverTargets_.AddEntriesFrom(input, _repeated_serverTargets_codec); 1944 break; 1945 } 1946 case 16: { 1947 ClientType = (global::Grpc.Testing.ClientType) input.ReadEnum(); 1948 break; 1949 } 1950 case 26: { 1951 if (securityParams_ == null) { 1952 SecurityParams = new global::Grpc.Testing.SecurityParams(); 1953 } 1954 input.ReadMessage(SecurityParams); 1955 break; 1956 } 1957 case 32: { 1958 OutstandingRpcsPerChannel = input.ReadInt32(); 1959 break; 1960 } 1961 case 40: { 1962 ClientChannels = input.ReadInt32(); 1963 break; 1964 } 1965 case 56: { 1966 AsyncClientThreads = input.ReadInt32(); 1967 break; 1968 } 1969 case 64: { 1970 RpcType = (global::Grpc.Testing.RpcType) input.ReadEnum(); 1971 break; 1972 } 1973 case 82: { 1974 if (loadParams_ == null) { 1975 LoadParams = new global::Grpc.Testing.LoadParams(); 1976 } 1977 input.ReadMessage(LoadParams); 1978 break; 1979 } 1980 case 90: { 1981 if (payloadConfig_ == null) { 1982 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 1983 } 1984 input.ReadMessage(PayloadConfig); 1985 break; 1986 } 1987 case 98: { 1988 if (histogramParams_ == null) { 1989 HistogramParams = new global::Grpc.Testing.HistogramParams(); 1990 } 1991 input.ReadMessage(HistogramParams); 1992 break; 1993 } 1994 case 106: 1995 case 104: { 1996 coreList_.AddEntriesFrom(input, _repeated_coreList_codec); 1997 break; 1998 } 1999 case 112: { 2000 CoreLimit = input.ReadInt32(); 2001 break; 2002 } 2003 case 122: { 2004 OtherClientApi = input.ReadString(); 2005 break; 2006 } 2007 case 130: { 2008 channelArgs_.AddEntriesFrom(input, _repeated_channelArgs_codec); 2009 break; 2010 } 2011 case 136: { 2012 ThreadsPerCq = input.ReadInt32(); 2013 break; 2014 } 2015 case 144: { 2016 MessagesPerStream = input.ReadInt32(); 2017 break; 2018 } 2019 case 152: { 2020 UseCoalesceApi = input.ReadBool(); 2021 break; 2022 } 2023 case 160: { 2024 MedianLatencyCollectionIntervalMillis = input.ReadInt32(); 2025 break; 2026 } 2027 case 168: { 2028 ClientProcesses = input.ReadInt32(); 2029 break; 2030 } 2031 } 2032 } 2033 #endif 2034 } 2035 2036 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2037 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)2038 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 2039 uint tag; 2040 while ((tag = input.ReadTag()) != 0) { 2041 switch(tag) { 2042 default: 2043 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 2044 break; 2045 case 10: { 2046 serverTargets_.AddEntriesFrom(ref input, _repeated_serverTargets_codec); 2047 break; 2048 } 2049 case 16: { 2050 ClientType = (global::Grpc.Testing.ClientType) input.ReadEnum(); 2051 break; 2052 } 2053 case 26: { 2054 if (securityParams_ == null) { 2055 SecurityParams = new global::Grpc.Testing.SecurityParams(); 2056 } 2057 input.ReadMessage(SecurityParams); 2058 break; 2059 } 2060 case 32: { 2061 OutstandingRpcsPerChannel = input.ReadInt32(); 2062 break; 2063 } 2064 case 40: { 2065 ClientChannels = input.ReadInt32(); 2066 break; 2067 } 2068 case 56: { 2069 AsyncClientThreads = input.ReadInt32(); 2070 break; 2071 } 2072 case 64: { 2073 RpcType = (global::Grpc.Testing.RpcType) input.ReadEnum(); 2074 break; 2075 } 2076 case 82: { 2077 if (loadParams_ == null) { 2078 LoadParams = new global::Grpc.Testing.LoadParams(); 2079 } 2080 input.ReadMessage(LoadParams); 2081 break; 2082 } 2083 case 90: { 2084 if (payloadConfig_ == null) { 2085 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 2086 } 2087 input.ReadMessage(PayloadConfig); 2088 break; 2089 } 2090 case 98: { 2091 if (histogramParams_ == null) { 2092 HistogramParams = new global::Grpc.Testing.HistogramParams(); 2093 } 2094 input.ReadMessage(HistogramParams); 2095 break; 2096 } 2097 case 106: 2098 case 104: { 2099 coreList_.AddEntriesFrom(ref input, _repeated_coreList_codec); 2100 break; 2101 } 2102 case 112: { 2103 CoreLimit = input.ReadInt32(); 2104 break; 2105 } 2106 case 122: { 2107 OtherClientApi = input.ReadString(); 2108 break; 2109 } 2110 case 130: { 2111 channelArgs_.AddEntriesFrom(ref input, _repeated_channelArgs_codec); 2112 break; 2113 } 2114 case 136: { 2115 ThreadsPerCq = input.ReadInt32(); 2116 break; 2117 } 2118 case 144: { 2119 MessagesPerStream = input.ReadInt32(); 2120 break; 2121 } 2122 case 152: { 2123 UseCoalesceApi = input.ReadBool(); 2124 break; 2125 } 2126 case 160: { 2127 MedianLatencyCollectionIntervalMillis = input.ReadInt32(); 2128 break; 2129 } 2130 case 168: { 2131 ClientProcesses = input.ReadInt32(); 2132 break; 2133 } 2134 } 2135 } 2136 } 2137 #endif 2138 2139 } 2140 2141 public sealed partial class ClientStatus : pb::IMessage<ClientStatus> 2142 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2143 , pb::IBufferMessage 2144 #endif 2145 { 2146 private static readonly pb::MessageParser<ClientStatus> _parser = new pb::MessageParser<ClientStatus>(() => new ClientStatus()); 2147 private pb::UnknownFieldSet _unknownFields; 2148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2149 public static pb::MessageParser<ClientStatus> Parser { get { return _parser; } } 2150 2151 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2152 public static pbr::MessageDescriptor Descriptor { 2153 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[6]; } 2154 } 2155 2156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2157 pbr::MessageDescriptor pb::IMessage.Descriptor { 2158 get { return Descriptor; } 2159 } 2160 2161 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientStatus()2162 public ClientStatus() { 2163 OnConstruction(); 2164 } 2165 OnConstruction()2166 partial void OnConstruction(); 2167 2168 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientStatus(ClientStatus other)2169 public ClientStatus(ClientStatus other) : this() { 2170 stats_ = other.stats_ != null ? other.stats_.Clone() : null; 2171 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 2172 } 2173 2174 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()2175 public ClientStatus Clone() { 2176 return new ClientStatus(this); 2177 } 2178 2179 /// <summary>Field number for the "stats" field.</summary> 2180 public const int StatsFieldNumber = 1; 2181 private global::Grpc.Testing.ClientStats stats_; 2182 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2183 public global::Grpc.Testing.ClientStats Stats { 2184 get { return stats_; } 2185 set { 2186 stats_ = value; 2187 } 2188 } 2189 2190 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)2191 public override bool Equals(object other) { 2192 return Equals(other as ClientStatus); 2193 } 2194 2195 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ClientStatus other)2196 public bool Equals(ClientStatus other) { 2197 if (ReferenceEquals(other, null)) { 2198 return false; 2199 } 2200 if (ReferenceEquals(other, this)) { 2201 return true; 2202 } 2203 if (!object.Equals(Stats, other.Stats)) return false; 2204 return Equals(_unknownFields, other._unknownFields); 2205 } 2206 2207 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()2208 public override int GetHashCode() { 2209 int hash = 1; 2210 if (stats_ != null) hash ^= Stats.GetHashCode(); 2211 if (_unknownFields != null) { 2212 hash ^= _unknownFields.GetHashCode(); 2213 } 2214 return hash; 2215 } 2216 2217 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()2218 public override string ToString() { 2219 return pb::JsonFormatter.ToDiagnosticString(this); 2220 } 2221 2222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)2223 public void WriteTo(pb::CodedOutputStream output) { 2224 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2225 output.WriteRawMessage(this); 2226 #else 2227 if (stats_ != null) { 2228 output.WriteRawTag(10); 2229 output.WriteMessage(Stats); 2230 } 2231 if (_unknownFields != null) { 2232 _unknownFields.WriteTo(output); 2233 } 2234 #endif 2235 } 2236 2237 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2238 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)2239 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 2240 if (stats_ != null) { 2241 output.WriteRawTag(10); 2242 output.WriteMessage(Stats); 2243 } 2244 if (_unknownFields != null) { 2245 _unknownFields.WriteTo(ref output); 2246 } 2247 } 2248 #endif 2249 2250 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()2251 public int CalculateSize() { 2252 int size = 0; 2253 if (stats_ != null) { 2254 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Stats); 2255 } 2256 if (_unknownFields != null) { 2257 size += _unknownFields.CalculateSize(); 2258 } 2259 return size; 2260 } 2261 2262 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ClientStatus other)2263 public void MergeFrom(ClientStatus other) { 2264 if (other == null) { 2265 return; 2266 } 2267 if (other.stats_ != null) { 2268 if (stats_ == null) { 2269 Stats = new global::Grpc.Testing.ClientStats(); 2270 } 2271 Stats.MergeFrom(other.Stats); 2272 } 2273 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 2274 } 2275 2276 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)2277 public void MergeFrom(pb::CodedInputStream input) { 2278 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2279 input.ReadRawMessage(this); 2280 #else 2281 uint tag; 2282 while ((tag = input.ReadTag()) != 0) { 2283 switch(tag) { 2284 default: 2285 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 2286 break; 2287 case 10: { 2288 if (stats_ == null) { 2289 Stats = new global::Grpc.Testing.ClientStats(); 2290 } 2291 input.ReadMessage(Stats); 2292 break; 2293 } 2294 } 2295 } 2296 #endif 2297 } 2298 2299 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2300 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)2301 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 2302 uint tag; 2303 while ((tag = input.ReadTag()) != 0) { 2304 switch(tag) { 2305 default: 2306 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 2307 break; 2308 case 10: { 2309 if (stats_ == null) { 2310 Stats = new global::Grpc.Testing.ClientStats(); 2311 } 2312 input.ReadMessage(Stats); 2313 break; 2314 } 2315 } 2316 } 2317 } 2318 #endif 2319 2320 } 2321 2322 /// <summary> 2323 /// Request current stats 2324 /// </summary> 2325 public sealed partial class Mark : pb::IMessage<Mark> 2326 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2327 , pb::IBufferMessage 2328 #endif 2329 { 2330 private static readonly pb::MessageParser<Mark> _parser = new pb::MessageParser<Mark>(() => new Mark()); 2331 private pb::UnknownFieldSet _unknownFields; 2332 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2333 public static pb::MessageParser<Mark> Parser { get { return _parser; } } 2334 2335 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2336 public static pbr::MessageDescriptor Descriptor { 2337 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[7]; } 2338 } 2339 2340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2341 pbr::MessageDescriptor pb::IMessage.Descriptor { 2342 get { return Descriptor; } 2343 } 2344 2345 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Mark()2346 public Mark() { 2347 OnConstruction(); 2348 } 2349 OnConstruction()2350 partial void OnConstruction(); 2351 2352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Mark(Mark other)2353 public Mark(Mark other) : this() { 2354 reset_ = other.reset_; 2355 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 2356 } 2357 2358 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()2359 public Mark Clone() { 2360 return new Mark(this); 2361 } 2362 2363 /// <summary>Field number for the "reset" field.</summary> 2364 public const int ResetFieldNumber = 1; 2365 private bool reset_; 2366 /// <summary> 2367 /// if true, the stats will be reset after taking their snapshot. 2368 /// </summary> 2369 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2370 public bool Reset { 2371 get { return reset_; } 2372 set { 2373 reset_ = value; 2374 } 2375 } 2376 2377 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)2378 public override bool Equals(object other) { 2379 return Equals(other as Mark); 2380 } 2381 2382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(Mark other)2383 public bool Equals(Mark other) { 2384 if (ReferenceEquals(other, null)) { 2385 return false; 2386 } 2387 if (ReferenceEquals(other, this)) { 2388 return true; 2389 } 2390 if (Reset != other.Reset) return false; 2391 return Equals(_unknownFields, other._unknownFields); 2392 } 2393 2394 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()2395 public override int GetHashCode() { 2396 int hash = 1; 2397 if (Reset != false) hash ^= Reset.GetHashCode(); 2398 if (_unknownFields != null) { 2399 hash ^= _unknownFields.GetHashCode(); 2400 } 2401 return hash; 2402 } 2403 2404 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()2405 public override string ToString() { 2406 return pb::JsonFormatter.ToDiagnosticString(this); 2407 } 2408 2409 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)2410 public void WriteTo(pb::CodedOutputStream output) { 2411 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2412 output.WriteRawMessage(this); 2413 #else 2414 if (Reset != false) { 2415 output.WriteRawTag(8); 2416 output.WriteBool(Reset); 2417 } 2418 if (_unknownFields != null) { 2419 _unknownFields.WriteTo(output); 2420 } 2421 #endif 2422 } 2423 2424 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)2426 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 2427 if (Reset != false) { 2428 output.WriteRawTag(8); 2429 output.WriteBool(Reset); 2430 } 2431 if (_unknownFields != null) { 2432 _unknownFields.WriteTo(ref output); 2433 } 2434 } 2435 #endif 2436 2437 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()2438 public int CalculateSize() { 2439 int size = 0; 2440 if (Reset != false) { 2441 size += 1 + 1; 2442 } 2443 if (_unknownFields != null) { 2444 size += _unknownFields.CalculateSize(); 2445 } 2446 return size; 2447 } 2448 2449 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(Mark other)2450 public void MergeFrom(Mark other) { 2451 if (other == null) { 2452 return; 2453 } 2454 if (other.Reset != false) { 2455 Reset = other.Reset; 2456 } 2457 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 2458 } 2459 2460 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)2461 public void MergeFrom(pb::CodedInputStream input) { 2462 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2463 input.ReadRawMessage(this); 2464 #else 2465 uint tag; 2466 while ((tag = input.ReadTag()) != 0) { 2467 switch(tag) { 2468 default: 2469 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 2470 break; 2471 case 8: { 2472 Reset = input.ReadBool(); 2473 break; 2474 } 2475 } 2476 } 2477 #endif 2478 } 2479 2480 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)2482 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 2483 uint tag; 2484 while ((tag = input.ReadTag()) != 0) { 2485 switch(tag) { 2486 default: 2487 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 2488 break; 2489 case 8: { 2490 Reset = input.ReadBool(); 2491 break; 2492 } 2493 } 2494 } 2495 } 2496 #endif 2497 2498 } 2499 2500 public sealed partial class ClientArgs : pb::IMessage<ClientArgs> 2501 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2502 , pb::IBufferMessage 2503 #endif 2504 { 2505 private static readonly pb::MessageParser<ClientArgs> _parser = new pb::MessageParser<ClientArgs>(() => new ClientArgs()); 2506 private pb::UnknownFieldSet _unknownFields; 2507 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2508 public static pb::MessageParser<ClientArgs> Parser { get { return _parser; } } 2509 2510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2511 public static pbr::MessageDescriptor Descriptor { 2512 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[8]; } 2513 } 2514 2515 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2516 pbr::MessageDescriptor pb::IMessage.Descriptor { 2517 get { return Descriptor; } 2518 } 2519 2520 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientArgs()2521 public ClientArgs() { 2522 OnConstruction(); 2523 } 2524 OnConstruction()2525 partial void OnConstruction(); 2526 2527 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientArgs(ClientArgs other)2528 public ClientArgs(ClientArgs other) : this() { 2529 switch (other.ArgtypeCase) { 2530 case ArgtypeOneofCase.Setup: 2531 Setup = other.Setup.Clone(); 2532 break; 2533 case ArgtypeOneofCase.Mark: 2534 Mark = other.Mark.Clone(); 2535 break; 2536 } 2537 2538 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 2539 } 2540 2541 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()2542 public ClientArgs Clone() { 2543 return new ClientArgs(this); 2544 } 2545 2546 /// <summary>Field number for the "setup" field.</summary> 2547 public const int SetupFieldNumber = 1; 2548 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2549 public global::Grpc.Testing.ClientConfig Setup { 2550 get { return argtypeCase_ == ArgtypeOneofCase.Setup ? (global::Grpc.Testing.ClientConfig) argtype_ : null; } 2551 set { 2552 argtype_ = value; 2553 argtypeCase_ = value == null ? ArgtypeOneofCase.None : ArgtypeOneofCase.Setup; 2554 } 2555 } 2556 2557 /// <summary>Field number for the "mark" field.</summary> 2558 public const int MarkFieldNumber = 2; 2559 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2560 public global::Grpc.Testing.Mark Mark { 2561 get { return argtypeCase_ == ArgtypeOneofCase.Mark ? (global::Grpc.Testing.Mark) argtype_ : null; } 2562 set { 2563 argtype_ = value; 2564 argtypeCase_ = value == null ? ArgtypeOneofCase.None : ArgtypeOneofCase.Mark; 2565 } 2566 } 2567 2568 private object argtype_; 2569 /// <summary>Enum of possible cases for the "argtype" oneof.</summary> 2570 public enum ArgtypeOneofCase { 2571 None = 0, 2572 Setup = 1, 2573 Mark = 2, 2574 } 2575 private ArgtypeOneofCase argtypeCase_ = ArgtypeOneofCase.None; 2576 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2577 public ArgtypeOneofCase ArgtypeCase { 2578 get { return argtypeCase_; } 2579 } 2580 2581 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClearArgtype()2582 public void ClearArgtype() { 2583 argtypeCase_ = ArgtypeOneofCase.None; 2584 argtype_ = null; 2585 } 2586 2587 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)2588 public override bool Equals(object other) { 2589 return Equals(other as ClientArgs); 2590 } 2591 2592 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ClientArgs other)2593 public bool Equals(ClientArgs other) { 2594 if (ReferenceEquals(other, null)) { 2595 return false; 2596 } 2597 if (ReferenceEquals(other, this)) { 2598 return true; 2599 } 2600 if (!object.Equals(Setup, other.Setup)) return false; 2601 if (!object.Equals(Mark, other.Mark)) return false; 2602 if (ArgtypeCase != other.ArgtypeCase) return false; 2603 return Equals(_unknownFields, other._unknownFields); 2604 } 2605 2606 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()2607 public override int GetHashCode() { 2608 int hash = 1; 2609 if (argtypeCase_ == ArgtypeOneofCase.Setup) hash ^= Setup.GetHashCode(); 2610 if (argtypeCase_ == ArgtypeOneofCase.Mark) hash ^= Mark.GetHashCode(); 2611 hash ^= (int) argtypeCase_; 2612 if (_unknownFields != null) { 2613 hash ^= _unknownFields.GetHashCode(); 2614 } 2615 return hash; 2616 } 2617 2618 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()2619 public override string ToString() { 2620 return pb::JsonFormatter.ToDiagnosticString(this); 2621 } 2622 2623 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)2624 public void WriteTo(pb::CodedOutputStream output) { 2625 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2626 output.WriteRawMessage(this); 2627 #else 2628 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2629 output.WriteRawTag(10); 2630 output.WriteMessage(Setup); 2631 } 2632 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2633 output.WriteRawTag(18); 2634 output.WriteMessage(Mark); 2635 } 2636 if (_unknownFields != null) { 2637 _unknownFields.WriteTo(output); 2638 } 2639 #endif 2640 } 2641 2642 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2643 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)2644 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 2645 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2646 output.WriteRawTag(10); 2647 output.WriteMessage(Setup); 2648 } 2649 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2650 output.WriteRawTag(18); 2651 output.WriteMessage(Mark); 2652 } 2653 if (_unknownFields != null) { 2654 _unknownFields.WriteTo(ref output); 2655 } 2656 } 2657 #endif 2658 2659 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()2660 public int CalculateSize() { 2661 int size = 0; 2662 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2663 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Setup); 2664 } 2665 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2666 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Mark); 2667 } 2668 if (_unknownFields != null) { 2669 size += _unknownFields.CalculateSize(); 2670 } 2671 return size; 2672 } 2673 2674 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ClientArgs other)2675 public void MergeFrom(ClientArgs other) { 2676 if (other == null) { 2677 return; 2678 } 2679 switch (other.ArgtypeCase) { 2680 case ArgtypeOneofCase.Setup: 2681 if (Setup == null) { 2682 Setup = new global::Grpc.Testing.ClientConfig(); 2683 } 2684 Setup.MergeFrom(other.Setup); 2685 break; 2686 case ArgtypeOneofCase.Mark: 2687 if (Mark == null) { 2688 Mark = new global::Grpc.Testing.Mark(); 2689 } 2690 Mark.MergeFrom(other.Mark); 2691 break; 2692 } 2693 2694 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 2695 } 2696 2697 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)2698 public void MergeFrom(pb::CodedInputStream input) { 2699 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2700 input.ReadRawMessage(this); 2701 #else 2702 uint tag; 2703 while ((tag = input.ReadTag()) != 0) { 2704 switch(tag) { 2705 default: 2706 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 2707 break; 2708 case 10: { 2709 global::Grpc.Testing.ClientConfig subBuilder = new global::Grpc.Testing.ClientConfig(); 2710 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2711 subBuilder.MergeFrom(Setup); 2712 } 2713 input.ReadMessage(subBuilder); 2714 Setup = subBuilder; 2715 break; 2716 } 2717 case 18: { 2718 global::Grpc.Testing.Mark subBuilder = new global::Grpc.Testing.Mark(); 2719 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2720 subBuilder.MergeFrom(Mark); 2721 } 2722 input.ReadMessage(subBuilder); 2723 Mark = subBuilder; 2724 break; 2725 } 2726 } 2727 } 2728 #endif 2729 } 2730 2731 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2732 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)2733 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 2734 uint tag; 2735 while ((tag = input.ReadTag()) != 0) { 2736 switch(tag) { 2737 default: 2738 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 2739 break; 2740 case 10: { 2741 global::Grpc.Testing.ClientConfig subBuilder = new global::Grpc.Testing.ClientConfig(); 2742 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2743 subBuilder.MergeFrom(Setup); 2744 } 2745 input.ReadMessage(subBuilder); 2746 Setup = subBuilder; 2747 break; 2748 } 2749 case 18: { 2750 global::Grpc.Testing.Mark subBuilder = new global::Grpc.Testing.Mark(); 2751 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2752 subBuilder.MergeFrom(Mark); 2753 } 2754 input.ReadMessage(subBuilder); 2755 Mark = subBuilder; 2756 break; 2757 } 2758 } 2759 } 2760 } 2761 #endif 2762 2763 } 2764 2765 public sealed partial class ServerConfig : pb::IMessage<ServerConfig> 2766 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 2767 , pb::IBufferMessage 2768 #endif 2769 { 2770 private static readonly pb::MessageParser<ServerConfig> _parser = new pb::MessageParser<ServerConfig>(() => new ServerConfig()); 2771 private pb::UnknownFieldSet _unknownFields; 2772 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2773 public static pb::MessageParser<ServerConfig> Parser { get { return _parser; } } 2774 2775 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2776 public static pbr::MessageDescriptor Descriptor { 2777 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[9]; } 2778 } 2779 2780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2781 pbr::MessageDescriptor pb::IMessage.Descriptor { 2782 get { return Descriptor; } 2783 } 2784 2785 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerConfig()2786 public ServerConfig() { 2787 OnConstruction(); 2788 } 2789 OnConstruction()2790 partial void OnConstruction(); 2791 2792 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerConfig(ServerConfig other)2793 public ServerConfig(ServerConfig other) : this() { 2794 serverType_ = other.serverType_; 2795 securityParams_ = other.securityParams_ != null ? other.securityParams_.Clone() : null; 2796 port_ = other.port_; 2797 asyncServerThreads_ = other.asyncServerThreads_; 2798 coreLimit_ = other.coreLimit_; 2799 payloadConfig_ = other.payloadConfig_ != null ? other.payloadConfig_.Clone() : null; 2800 coreList_ = other.coreList_.Clone(); 2801 otherServerApi_ = other.otherServerApi_; 2802 threadsPerCq_ = other.threadsPerCq_; 2803 resourceQuotaSize_ = other.resourceQuotaSize_; 2804 channelArgs_ = other.channelArgs_.Clone(); 2805 serverProcesses_ = other.serverProcesses_; 2806 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 2807 } 2808 2809 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()2810 public ServerConfig Clone() { 2811 return new ServerConfig(this); 2812 } 2813 2814 /// <summary>Field number for the "server_type" field.</summary> 2815 public const int ServerTypeFieldNumber = 1; 2816 private global::Grpc.Testing.ServerType serverType_ = global::Grpc.Testing.ServerType.SyncServer; 2817 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2818 public global::Grpc.Testing.ServerType ServerType { 2819 get { return serverType_; } 2820 set { 2821 serverType_ = value; 2822 } 2823 } 2824 2825 /// <summary>Field number for the "security_params" field.</summary> 2826 public const int SecurityParamsFieldNumber = 2; 2827 private global::Grpc.Testing.SecurityParams securityParams_; 2828 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2829 public global::Grpc.Testing.SecurityParams SecurityParams { 2830 get { return securityParams_; } 2831 set { 2832 securityParams_ = value; 2833 } 2834 } 2835 2836 /// <summary>Field number for the "port" field.</summary> 2837 public const int PortFieldNumber = 4; 2838 private int port_; 2839 /// <summary> 2840 /// Port on which to listen. Zero means pick unused port. 2841 /// </summary> 2842 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2843 public int Port { 2844 get { return port_; } 2845 set { 2846 port_ = value; 2847 } 2848 } 2849 2850 /// <summary>Field number for the "async_server_threads" field.</summary> 2851 public const int AsyncServerThreadsFieldNumber = 7; 2852 private int asyncServerThreads_; 2853 /// <summary> 2854 /// Only for async server. Number of threads used to serve the requests. 2855 /// </summary> 2856 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2857 public int AsyncServerThreads { 2858 get { return asyncServerThreads_; } 2859 set { 2860 asyncServerThreads_ = value; 2861 } 2862 } 2863 2864 /// <summary>Field number for the "core_limit" field.</summary> 2865 public const int CoreLimitFieldNumber = 8; 2866 private int coreLimit_; 2867 /// <summary> 2868 /// Specify the number of cores to limit server to, if desired 2869 /// </summary> 2870 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2871 public int CoreLimit { 2872 get { return coreLimit_; } 2873 set { 2874 coreLimit_ = value; 2875 } 2876 } 2877 2878 /// <summary>Field number for the "payload_config" field.</summary> 2879 public const int PayloadConfigFieldNumber = 9; 2880 private global::Grpc.Testing.PayloadConfig payloadConfig_; 2881 /// <summary> 2882 /// payload config, used in generic server. 2883 /// Note this must NOT be used in proto (non-generic) servers. For proto servers, 2884 /// 'response sizes' must be configured from the 'response_size' field of the 2885 /// 'SimpleRequest' objects in RPC requests. 2886 /// </summary> 2887 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2888 public global::Grpc.Testing.PayloadConfig PayloadConfig { 2889 get { return payloadConfig_; } 2890 set { 2891 payloadConfig_ = value; 2892 } 2893 } 2894 2895 /// <summary>Field number for the "core_list" field.</summary> 2896 public const int CoreListFieldNumber = 10; 2897 private static readonly pb::FieldCodec<int> _repeated_coreList_codec 2898 = pb::FieldCodec.ForInt32(82); 2899 private readonly pbc::RepeatedField<int> coreList_ = new pbc::RepeatedField<int>(); 2900 /// <summary> 2901 /// Specify the cores we should run the server on, if desired 2902 /// </summary> 2903 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2904 public pbc::RepeatedField<int> CoreList { 2905 get { return coreList_; } 2906 } 2907 2908 /// <summary>Field number for the "other_server_api" field.</summary> 2909 public const int OtherServerApiFieldNumber = 11; 2910 private string otherServerApi_ = ""; 2911 /// <summary> 2912 /// If we use an OTHER_SERVER client_type, this string gives more detail 2913 /// </summary> 2914 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2915 public string OtherServerApi { 2916 get { return otherServerApi_; } 2917 set { 2918 otherServerApi_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 2919 } 2920 } 2921 2922 /// <summary>Field number for the "threads_per_cq" field.</summary> 2923 public const int ThreadsPerCqFieldNumber = 12; 2924 private int threadsPerCq_; 2925 /// <summary> 2926 /// Number of threads that share each completion queue 2927 /// </summary> 2928 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2929 public int ThreadsPerCq { 2930 get { return threadsPerCq_; } 2931 set { 2932 threadsPerCq_ = value; 2933 } 2934 } 2935 2936 /// <summary>Field number for the "resource_quota_size" field.</summary> 2937 public const int ResourceQuotaSizeFieldNumber = 1001; 2938 private int resourceQuotaSize_; 2939 /// <summary> 2940 /// Buffer pool size (no buffer pool specified if unset) 2941 /// </summary> 2942 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2943 public int ResourceQuotaSize { 2944 get { return resourceQuotaSize_; } 2945 set { 2946 resourceQuotaSize_ = value; 2947 } 2948 } 2949 2950 /// <summary>Field number for the "channel_args" field.</summary> 2951 public const int ChannelArgsFieldNumber = 1002; 2952 private static readonly pb::FieldCodec<global::Grpc.Testing.ChannelArg> _repeated_channelArgs_codec 2953 = pb::FieldCodec.ForMessage(8018, global::Grpc.Testing.ChannelArg.Parser); 2954 private readonly pbc::RepeatedField<global::Grpc.Testing.ChannelArg> channelArgs_ = new pbc::RepeatedField<global::Grpc.Testing.ChannelArg>(); 2955 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2956 public pbc::RepeatedField<global::Grpc.Testing.ChannelArg> ChannelArgs { 2957 get { return channelArgs_; } 2958 } 2959 2960 /// <summary>Field number for the "server_processes" field.</summary> 2961 public const int ServerProcessesFieldNumber = 21; 2962 private int serverProcesses_; 2963 /// <summary> 2964 /// Number of server processes. 0 indicates no restriction. 2965 /// </summary> 2966 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2967 public int ServerProcesses { 2968 get { return serverProcesses_; } 2969 set { 2970 serverProcesses_ = value; 2971 } 2972 } 2973 2974 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)2975 public override bool Equals(object other) { 2976 return Equals(other as ServerConfig); 2977 } 2978 2979 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ServerConfig other)2980 public bool Equals(ServerConfig other) { 2981 if (ReferenceEquals(other, null)) { 2982 return false; 2983 } 2984 if (ReferenceEquals(other, this)) { 2985 return true; 2986 } 2987 if (ServerType != other.ServerType) return false; 2988 if (!object.Equals(SecurityParams, other.SecurityParams)) return false; 2989 if (Port != other.Port) return false; 2990 if (AsyncServerThreads != other.AsyncServerThreads) return false; 2991 if (CoreLimit != other.CoreLimit) return false; 2992 if (!object.Equals(PayloadConfig, other.PayloadConfig)) return false; 2993 if(!coreList_.Equals(other.coreList_)) return false; 2994 if (OtherServerApi != other.OtherServerApi) return false; 2995 if (ThreadsPerCq != other.ThreadsPerCq) return false; 2996 if (ResourceQuotaSize != other.ResourceQuotaSize) return false; 2997 if(!channelArgs_.Equals(other.channelArgs_)) return false; 2998 if (ServerProcesses != other.ServerProcesses) return false; 2999 return Equals(_unknownFields, other._unknownFields); 3000 } 3001 3002 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()3003 public override int GetHashCode() { 3004 int hash = 1; 3005 if (ServerType != global::Grpc.Testing.ServerType.SyncServer) hash ^= ServerType.GetHashCode(); 3006 if (securityParams_ != null) hash ^= SecurityParams.GetHashCode(); 3007 if (Port != 0) hash ^= Port.GetHashCode(); 3008 if (AsyncServerThreads != 0) hash ^= AsyncServerThreads.GetHashCode(); 3009 if (CoreLimit != 0) hash ^= CoreLimit.GetHashCode(); 3010 if (payloadConfig_ != null) hash ^= PayloadConfig.GetHashCode(); 3011 hash ^= coreList_.GetHashCode(); 3012 if (OtherServerApi.Length != 0) hash ^= OtherServerApi.GetHashCode(); 3013 if (ThreadsPerCq != 0) hash ^= ThreadsPerCq.GetHashCode(); 3014 if (ResourceQuotaSize != 0) hash ^= ResourceQuotaSize.GetHashCode(); 3015 hash ^= channelArgs_.GetHashCode(); 3016 if (ServerProcesses != 0) hash ^= ServerProcesses.GetHashCode(); 3017 if (_unknownFields != null) { 3018 hash ^= _unknownFields.GetHashCode(); 3019 } 3020 return hash; 3021 } 3022 3023 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()3024 public override string ToString() { 3025 return pb::JsonFormatter.ToDiagnosticString(this); 3026 } 3027 3028 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)3029 public void WriteTo(pb::CodedOutputStream output) { 3030 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3031 output.WriteRawMessage(this); 3032 #else 3033 if (ServerType != global::Grpc.Testing.ServerType.SyncServer) { 3034 output.WriteRawTag(8); 3035 output.WriteEnum((int) ServerType); 3036 } 3037 if (securityParams_ != null) { 3038 output.WriteRawTag(18); 3039 output.WriteMessage(SecurityParams); 3040 } 3041 if (Port != 0) { 3042 output.WriteRawTag(32); 3043 output.WriteInt32(Port); 3044 } 3045 if (AsyncServerThreads != 0) { 3046 output.WriteRawTag(56); 3047 output.WriteInt32(AsyncServerThreads); 3048 } 3049 if (CoreLimit != 0) { 3050 output.WriteRawTag(64); 3051 output.WriteInt32(CoreLimit); 3052 } 3053 if (payloadConfig_ != null) { 3054 output.WriteRawTag(74); 3055 output.WriteMessage(PayloadConfig); 3056 } 3057 coreList_.WriteTo(output, _repeated_coreList_codec); 3058 if (OtherServerApi.Length != 0) { 3059 output.WriteRawTag(90); 3060 output.WriteString(OtherServerApi); 3061 } 3062 if (ThreadsPerCq != 0) { 3063 output.WriteRawTag(96); 3064 output.WriteInt32(ThreadsPerCq); 3065 } 3066 if (ServerProcesses != 0) { 3067 output.WriteRawTag(168, 1); 3068 output.WriteInt32(ServerProcesses); 3069 } 3070 if (ResourceQuotaSize != 0) { 3071 output.WriteRawTag(200, 62); 3072 output.WriteInt32(ResourceQuotaSize); 3073 } 3074 channelArgs_.WriteTo(output, _repeated_channelArgs_codec); 3075 if (_unknownFields != null) { 3076 _unknownFields.WriteTo(output); 3077 } 3078 #endif 3079 } 3080 3081 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3082 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)3083 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 3084 if (ServerType != global::Grpc.Testing.ServerType.SyncServer) { 3085 output.WriteRawTag(8); 3086 output.WriteEnum((int) ServerType); 3087 } 3088 if (securityParams_ != null) { 3089 output.WriteRawTag(18); 3090 output.WriteMessage(SecurityParams); 3091 } 3092 if (Port != 0) { 3093 output.WriteRawTag(32); 3094 output.WriteInt32(Port); 3095 } 3096 if (AsyncServerThreads != 0) { 3097 output.WriteRawTag(56); 3098 output.WriteInt32(AsyncServerThreads); 3099 } 3100 if (CoreLimit != 0) { 3101 output.WriteRawTag(64); 3102 output.WriteInt32(CoreLimit); 3103 } 3104 if (payloadConfig_ != null) { 3105 output.WriteRawTag(74); 3106 output.WriteMessage(PayloadConfig); 3107 } 3108 coreList_.WriteTo(ref output, _repeated_coreList_codec); 3109 if (OtherServerApi.Length != 0) { 3110 output.WriteRawTag(90); 3111 output.WriteString(OtherServerApi); 3112 } 3113 if (ThreadsPerCq != 0) { 3114 output.WriteRawTag(96); 3115 output.WriteInt32(ThreadsPerCq); 3116 } 3117 if (ServerProcesses != 0) { 3118 output.WriteRawTag(168, 1); 3119 output.WriteInt32(ServerProcesses); 3120 } 3121 if (ResourceQuotaSize != 0) { 3122 output.WriteRawTag(200, 62); 3123 output.WriteInt32(ResourceQuotaSize); 3124 } 3125 channelArgs_.WriteTo(ref output, _repeated_channelArgs_codec); 3126 if (_unknownFields != null) { 3127 _unknownFields.WriteTo(ref output); 3128 } 3129 } 3130 #endif 3131 3132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()3133 public int CalculateSize() { 3134 int size = 0; 3135 if (ServerType != global::Grpc.Testing.ServerType.SyncServer) { 3136 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) ServerType); 3137 } 3138 if (securityParams_ != null) { 3139 size += 1 + pb::CodedOutputStream.ComputeMessageSize(SecurityParams); 3140 } 3141 if (Port != 0) { 3142 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Port); 3143 } 3144 if (AsyncServerThreads != 0) { 3145 size += 1 + pb::CodedOutputStream.ComputeInt32Size(AsyncServerThreads); 3146 } 3147 if (CoreLimit != 0) { 3148 size += 1 + pb::CodedOutputStream.ComputeInt32Size(CoreLimit); 3149 } 3150 if (payloadConfig_ != null) { 3151 size += 1 + pb::CodedOutputStream.ComputeMessageSize(PayloadConfig); 3152 } 3153 size += coreList_.CalculateSize(_repeated_coreList_codec); 3154 if (OtherServerApi.Length != 0) { 3155 size += 1 + pb::CodedOutputStream.ComputeStringSize(OtherServerApi); 3156 } 3157 if (ThreadsPerCq != 0) { 3158 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ThreadsPerCq); 3159 } 3160 if (ResourceQuotaSize != 0) { 3161 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ResourceQuotaSize); 3162 } 3163 size += channelArgs_.CalculateSize(_repeated_channelArgs_codec); 3164 if (ServerProcesses != 0) { 3165 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ServerProcesses); 3166 } 3167 if (_unknownFields != null) { 3168 size += _unknownFields.CalculateSize(); 3169 } 3170 return size; 3171 } 3172 3173 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ServerConfig other)3174 public void MergeFrom(ServerConfig other) { 3175 if (other == null) { 3176 return; 3177 } 3178 if (other.ServerType != global::Grpc.Testing.ServerType.SyncServer) { 3179 ServerType = other.ServerType; 3180 } 3181 if (other.securityParams_ != null) { 3182 if (securityParams_ == null) { 3183 SecurityParams = new global::Grpc.Testing.SecurityParams(); 3184 } 3185 SecurityParams.MergeFrom(other.SecurityParams); 3186 } 3187 if (other.Port != 0) { 3188 Port = other.Port; 3189 } 3190 if (other.AsyncServerThreads != 0) { 3191 AsyncServerThreads = other.AsyncServerThreads; 3192 } 3193 if (other.CoreLimit != 0) { 3194 CoreLimit = other.CoreLimit; 3195 } 3196 if (other.payloadConfig_ != null) { 3197 if (payloadConfig_ == null) { 3198 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 3199 } 3200 PayloadConfig.MergeFrom(other.PayloadConfig); 3201 } 3202 coreList_.Add(other.coreList_); 3203 if (other.OtherServerApi.Length != 0) { 3204 OtherServerApi = other.OtherServerApi; 3205 } 3206 if (other.ThreadsPerCq != 0) { 3207 ThreadsPerCq = other.ThreadsPerCq; 3208 } 3209 if (other.ResourceQuotaSize != 0) { 3210 ResourceQuotaSize = other.ResourceQuotaSize; 3211 } 3212 channelArgs_.Add(other.channelArgs_); 3213 if (other.ServerProcesses != 0) { 3214 ServerProcesses = other.ServerProcesses; 3215 } 3216 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3217 } 3218 3219 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3220 public void MergeFrom(pb::CodedInputStream input) { 3221 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3222 input.ReadRawMessage(this); 3223 #else 3224 uint tag; 3225 while ((tag = input.ReadTag()) != 0) { 3226 switch(tag) { 3227 default: 3228 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3229 break; 3230 case 8: { 3231 ServerType = (global::Grpc.Testing.ServerType) input.ReadEnum(); 3232 break; 3233 } 3234 case 18: { 3235 if (securityParams_ == null) { 3236 SecurityParams = new global::Grpc.Testing.SecurityParams(); 3237 } 3238 input.ReadMessage(SecurityParams); 3239 break; 3240 } 3241 case 32: { 3242 Port = input.ReadInt32(); 3243 break; 3244 } 3245 case 56: { 3246 AsyncServerThreads = input.ReadInt32(); 3247 break; 3248 } 3249 case 64: { 3250 CoreLimit = input.ReadInt32(); 3251 break; 3252 } 3253 case 74: { 3254 if (payloadConfig_ == null) { 3255 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 3256 } 3257 input.ReadMessage(PayloadConfig); 3258 break; 3259 } 3260 case 82: 3261 case 80: { 3262 coreList_.AddEntriesFrom(input, _repeated_coreList_codec); 3263 break; 3264 } 3265 case 90: { 3266 OtherServerApi = input.ReadString(); 3267 break; 3268 } 3269 case 96: { 3270 ThreadsPerCq = input.ReadInt32(); 3271 break; 3272 } 3273 case 168: { 3274 ServerProcesses = input.ReadInt32(); 3275 break; 3276 } 3277 case 8008: { 3278 ResourceQuotaSize = input.ReadInt32(); 3279 break; 3280 } 3281 case 8018: { 3282 channelArgs_.AddEntriesFrom(input, _repeated_channelArgs_codec); 3283 break; 3284 } 3285 } 3286 } 3287 #endif 3288 } 3289 3290 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3291 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)3292 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 3293 uint tag; 3294 while ((tag = input.ReadTag()) != 0) { 3295 switch(tag) { 3296 default: 3297 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 3298 break; 3299 case 8: { 3300 ServerType = (global::Grpc.Testing.ServerType) input.ReadEnum(); 3301 break; 3302 } 3303 case 18: { 3304 if (securityParams_ == null) { 3305 SecurityParams = new global::Grpc.Testing.SecurityParams(); 3306 } 3307 input.ReadMessage(SecurityParams); 3308 break; 3309 } 3310 case 32: { 3311 Port = input.ReadInt32(); 3312 break; 3313 } 3314 case 56: { 3315 AsyncServerThreads = input.ReadInt32(); 3316 break; 3317 } 3318 case 64: { 3319 CoreLimit = input.ReadInt32(); 3320 break; 3321 } 3322 case 74: { 3323 if (payloadConfig_ == null) { 3324 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 3325 } 3326 input.ReadMessage(PayloadConfig); 3327 break; 3328 } 3329 case 82: 3330 case 80: { 3331 coreList_.AddEntriesFrom(ref input, _repeated_coreList_codec); 3332 break; 3333 } 3334 case 90: { 3335 OtherServerApi = input.ReadString(); 3336 break; 3337 } 3338 case 96: { 3339 ThreadsPerCq = input.ReadInt32(); 3340 break; 3341 } 3342 case 168: { 3343 ServerProcesses = input.ReadInt32(); 3344 break; 3345 } 3346 case 8008: { 3347 ResourceQuotaSize = input.ReadInt32(); 3348 break; 3349 } 3350 case 8018: { 3351 channelArgs_.AddEntriesFrom(ref input, _repeated_channelArgs_codec); 3352 break; 3353 } 3354 } 3355 } 3356 } 3357 #endif 3358 3359 } 3360 3361 public sealed partial class ServerArgs : pb::IMessage<ServerArgs> 3362 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3363 , pb::IBufferMessage 3364 #endif 3365 { 3366 private static readonly pb::MessageParser<ServerArgs> _parser = new pb::MessageParser<ServerArgs>(() => new ServerArgs()); 3367 private pb::UnknownFieldSet _unknownFields; 3368 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3369 public static pb::MessageParser<ServerArgs> Parser { get { return _parser; } } 3370 3371 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3372 public static pbr::MessageDescriptor Descriptor { 3373 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[10]; } 3374 } 3375 3376 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3377 pbr::MessageDescriptor pb::IMessage.Descriptor { 3378 get { return Descriptor; } 3379 } 3380 3381 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerArgs()3382 public ServerArgs() { 3383 OnConstruction(); 3384 } 3385 OnConstruction()3386 partial void OnConstruction(); 3387 3388 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerArgs(ServerArgs other)3389 public ServerArgs(ServerArgs other) : this() { 3390 switch (other.ArgtypeCase) { 3391 case ArgtypeOneofCase.Setup: 3392 Setup = other.Setup.Clone(); 3393 break; 3394 case ArgtypeOneofCase.Mark: 3395 Mark = other.Mark.Clone(); 3396 break; 3397 } 3398 3399 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 3400 } 3401 3402 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()3403 public ServerArgs Clone() { 3404 return new ServerArgs(this); 3405 } 3406 3407 /// <summary>Field number for the "setup" field.</summary> 3408 public const int SetupFieldNumber = 1; 3409 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3410 public global::Grpc.Testing.ServerConfig Setup { 3411 get { return argtypeCase_ == ArgtypeOneofCase.Setup ? (global::Grpc.Testing.ServerConfig) argtype_ : null; } 3412 set { 3413 argtype_ = value; 3414 argtypeCase_ = value == null ? ArgtypeOneofCase.None : ArgtypeOneofCase.Setup; 3415 } 3416 } 3417 3418 /// <summary>Field number for the "mark" field.</summary> 3419 public const int MarkFieldNumber = 2; 3420 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3421 public global::Grpc.Testing.Mark Mark { 3422 get { return argtypeCase_ == ArgtypeOneofCase.Mark ? (global::Grpc.Testing.Mark) argtype_ : null; } 3423 set { 3424 argtype_ = value; 3425 argtypeCase_ = value == null ? ArgtypeOneofCase.None : ArgtypeOneofCase.Mark; 3426 } 3427 } 3428 3429 private object argtype_; 3430 /// <summary>Enum of possible cases for the "argtype" oneof.</summary> 3431 public enum ArgtypeOneofCase { 3432 None = 0, 3433 Setup = 1, 3434 Mark = 2, 3435 } 3436 private ArgtypeOneofCase argtypeCase_ = ArgtypeOneofCase.None; 3437 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3438 public ArgtypeOneofCase ArgtypeCase { 3439 get { return argtypeCase_; } 3440 } 3441 3442 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClearArgtype()3443 public void ClearArgtype() { 3444 argtypeCase_ = ArgtypeOneofCase.None; 3445 argtype_ = null; 3446 } 3447 3448 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)3449 public override bool Equals(object other) { 3450 return Equals(other as ServerArgs); 3451 } 3452 3453 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ServerArgs other)3454 public bool Equals(ServerArgs other) { 3455 if (ReferenceEquals(other, null)) { 3456 return false; 3457 } 3458 if (ReferenceEquals(other, this)) { 3459 return true; 3460 } 3461 if (!object.Equals(Setup, other.Setup)) return false; 3462 if (!object.Equals(Mark, other.Mark)) return false; 3463 if (ArgtypeCase != other.ArgtypeCase) return false; 3464 return Equals(_unknownFields, other._unknownFields); 3465 } 3466 3467 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()3468 public override int GetHashCode() { 3469 int hash = 1; 3470 if (argtypeCase_ == ArgtypeOneofCase.Setup) hash ^= Setup.GetHashCode(); 3471 if (argtypeCase_ == ArgtypeOneofCase.Mark) hash ^= Mark.GetHashCode(); 3472 hash ^= (int) argtypeCase_; 3473 if (_unknownFields != null) { 3474 hash ^= _unknownFields.GetHashCode(); 3475 } 3476 return hash; 3477 } 3478 3479 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()3480 public override string ToString() { 3481 return pb::JsonFormatter.ToDiagnosticString(this); 3482 } 3483 3484 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)3485 public void WriteTo(pb::CodedOutputStream output) { 3486 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3487 output.WriteRawMessage(this); 3488 #else 3489 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 3490 output.WriteRawTag(10); 3491 output.WriteMessage(Setup); 3492 } 3493 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 3494 output.WriteRawTag(18); 3495 output.WriteMessage(Mark); 3496 } 3497 if (_unknownFields != null) { 3498 _unknownFields.WriteTo(output); 3499 } 3500 #endif 3501 } 3502 3503 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3504 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)3505 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 3506 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 3507 output.WriteRawTag(10); 3508 output.WriteMessage(Setup); 3509 } 3510 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 3511 output.WriteRawTag(18); 3512 output.WriteMessage(Mark); 3513 } 3514 if (_unknownFields != null) { 3515 _unknownFields.WriteTo(ref output); 3516 } 3517 } 3518 #endif 3519 3520 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()3521 public int CalculateSize() { 3522 int size = 0; 3523 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 3524 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Setup); 3525 } 3526 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 3527 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Mark); 3528 } 3529 if (_unknownFields != null) { 3530 size += _unknownFields.CalculateSize(); 3531 } 3532 return size; 3533 } 3534 3535 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ServerArgs other)3536 public void MergeFrom(ServerArgs other) { 3537 if (other == null) { 3538 return; 3539 } 3540 switch (other.ArgtypeCase) { 3541 case ArgtypeOneofCase.Setup: 3542 if (Setup == null) { 3543 Setup = new global::Grpc.Testing.ServerConfig(); 3544 } 3545 Setup.MergeFrom(other.Setup); 3546 break; 3547 case ArgtypeOneofCase.Mark: 3548 if (Mark == null) { 3549 Mark = new global::Grpc.Testing.Mark(); 3550 } 3551 Mark.MergeFrom(other.Mark); 3552 break; 3553 } 3554 3555 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3556 } 3557 3558 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3559 public void MergeFrom(pb::CodedInputStream input) { 3560 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3561 input.ReadRawMessage(this); 3562 #else 3563 uint tag; 3564 while ((tag = input.ReadTag()) != 0) { 3565 switch(tag) { 3566 default: 3567 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3568 break; 3569 case 10: { 3570 global::Grpc.Testing.ServerConfig subBuilder = new global::Grpc.Testing.ServerConfig(); 3571 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 3572 subBuilder.MergeFrom(Setup); 3573 } 3574 input.ReadMessage(subBuilder); 3575 Setup = subBuilder; 3576 break; 3577 } 3578 case 18: { 3579 global::Grpc.Testing.Mark subBuilder = new global::Grpc.Testing.Mark(); 3580 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 3581 subBuilder.MergeFrom(Mark); 3582 } 3583 input.ReadMessage(subBuilder); 3584 Mark = subBuilder; 3585 break; 3586 } 3587 } 3588 } 3589 #endif 3590 } 3591 3592 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3593 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)3594 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 3595 uint tag; 3596 while ((tag = input.ReadTag()) != 0) { 3597 switch(tag) { 3598 default: 3599 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 3600 break; 3601 case 10: { 3602 global::Grpc.Testing.ServerConfig subBuilder = new global::Grpc.Testing.ServerConfig(); 3603 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 3604 subBuilder.MergeFrom(Setup); 3605 } 3606 input.ReadMessage(subBuilder); 3607 Setup = subBuilder; 3608 break; 3609 } 3610 case 18: { 3611 global::Grpc.Testing.Mark subBuilder = new global::Grpc.Testing.Mark(); 3612 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 3613 subBuilder.MergeFrom(Mark); 3614 } 3615 input.ReadMessage(subBuilder); 3616 Mark = subBuilder; 3617 break; 3618 } 3619 } 3620 } 3621 } 3622 #endif 3623 3624 } 3625 3626 public sealed partial class ServerStatus : pb::IMessage<ServerStatus> 3627 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3628 , pb::IBufferMessage 3629 #endif 3630 { 3631 private static readonly pb::MessageParser<ServerStatus> _parser = new pb::MessageParser<ServerStatus>(() => new ServerStatus()); 3632 private pb::UnknownFieldSet _unknownFields; 3633 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3634 public static pb::MessageParser<ServerStatus> Parser { get { return _parser; } } 3635 3636 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3637 public static pbr::MessageDescriptor Descriptor { 3638 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[11]; } 3639 } 3640 3641 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3642 pbr::MessageDescriptor pb::IMessage.Descriptor { 3643 get { return Descriptor; } 3644 } 3645 3646 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerStatus()3647 public ServerStatus() { 3648 OnConstruction(); 3649 } 3650 OnConstruction()3651 partial void OnConstruction(); 3652 3653 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerStatus(ServerStatus other)3654 public ServerStatus(ServerStatus other) : this() { 3655 stats_ = other.stats_ != null ? other.stats_.Clone() : null; 3656 port_ = other.port_; 3657 cores_ = other.cores_; 3658 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 3659 } 3660 3661 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()3662 public ServerStatus Clone() { 3663 return new ServerStatus(this); 3664 } 3665 3666 /// <summary>Field number for the "stats" field.</summary> 3667 public const int StatsFieldNumber = 1; 3668 private global::Grpc.Testing.ServerStats stats_; 3669 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3670 public global::Grpc.Testing.ServerStats Stats { 3671 get { return stats_; } 3672 set { 3673 stats_ = value; 3674 } 3675 } 3676 3677 /// <summary>Field number for the "port" field.</summary> 3678 public const int PortFieldNumber = 2; 3679 private int port_; 3680 /// <summary> 3681 /// the port bound by the server 3682 /// </summary> 3683 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3684 public int Port { 3685 get { return port_; } 3686 set { 3687 port_ = value; 3688 } 3689 } 3690 3691 /// <summary>Field number for the "cores" field.</summary> 3692 public const int CoresFieldNumber = 3; 3693 private int cores_; 3694 /// <summary> 3695 /// Number of cores available to the server 3696 /// </summary> 3697 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3698 public int Cores { 3699 get { return cores_; } 3700 set { 3701 cores_ = value; 3702 } 3703 } 3704 3705 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)3706 public override bool Equals(object other) { 3707 return Equals(other as ServerStatus); 3708 } 3709 3710 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ServerStatus other)3711 public bool Equals(ServerStatus other) { 3712 if (ReferenceEquals(other, null)) { 3713 return false; 3714 } 3715 if (ReferenceEquals(other, this)) { 3716 return true; 3717 } 3718 if (!object.Equals(Stats, other.Stats)) return false; 3719 if (Port != other.Port) return false; 3720 if (Cores != other.Cores) return false; 3721 return Equals(_unknownFields, other._unknownFields); 3722 } 3723 3724 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()3725 public override int GetHashCode() { 3726 int hash = 1; 3727 if (stats_ != null) hash ^= Stats.GetHashCode(); 3728 if (Port != 0) hash ^= Port.GetHashCode(); 3729 if (Cores != 0) hash ^= Cores.GetHashCode(); 3730 if (_unknownFields != null) { 3731 hash ^= _unknownFields.GetHashCode(); 3732 } 3733 return hash; 3734 } 3735 3736 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()3737 public override string ToString() { 3738 return pb::JsonFormatter.ToDiagnosticString(this); 3739 } 3740 3741 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)3742 public void WriteTo(pb::CodedOutputStream output) { 3743 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3744 output.WriteRawMessage(this); 3745 #else 3746 if (stats_ != null) { 3747 output.WriteRawTag(10); 3748 output.WriteMessage(Stats); 3749 } 3750 if (Port != 0) { 3751 output.WriteRawTag(16); 3752 output.WriteInt32(Port); 3753 } 3754 if (Cores != 0) { 3755 output.WriteRawTag(24); 3756 output.WriteInt32(Cores); 3757 } 3758 if (_unknownFields != null) { 3759 _unknownFields.WriteTo(output); 3760 } 3761 #endif 3762 } 3763 3764 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3765 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)3766 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 3767 if (stats_ != null) { 3768 output.WriteRawTag(10); 3769 output.WriteMessage(Stats); 3770 } 3771 if (Port != 0) { 3772 output.WriteRawTag(16); 3773 output.WriteInt32(Port); 3774 } 3775 if (Cores != 0) { 3776 output.WriteRawTag(24); 3777 output.WriteInt32(Cores); 3778 } 3779 if (_unknownFields != null) { 3780 _unknownFields.WriteTo(ref output); 3781 } 3782 } 3783 #endif 3784 3785 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()3786 public int CalculateSize() { 3787 int size = 0; 3788 if (stats_ != null) { 3789 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Stats); 3790 } 3791 if (Port != 0) { 3792 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Port); 3793 } 3794 if (Cores != 0) { 3795 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Cores); 3796 } 3797 if (_unknownFields != null) { 3798 size += _unknownFields.CalculateSize(); 3799 } 3800 return size; 3801 } 3802 3803 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ServerStatus other)3804 public void MergeFrom(ServerStatus other) { 3805 if (other == null) { 3806 return; 3807 } 3808 if (other.stats_ != null) { 3809 if (stats_ == null) { 3810 Stats = new global::Grpc.Testing.ServerStats(); 3811 } 3812 Stats.MergeFrom(other.Stats); 3813 } 3814 if (other.Port != 0) { 3815 Port = other.Port; 3816 } 3817 if (other.Cores != 0) { 3818 Cores = other.Cores; 3819 } 3820 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3821 } 3822 3823 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3824 public void MergeFrom(pb::CodedInputStream input) { 3825 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3826 input.ReadRawMessage(this); 3827 #else 3828 uint tag; 3829 while ((tag = input.ReadTag()) != 0) { 3830 switch(tag) { 3831 default: 3832 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3833 break; 3834 case 10: { 3835 if (stats_ == null) { 3836 Stats = new global::Grpc.Testing.ServerStats(); 3837 } 3838 input.ReadMessage(Stats); 3839 break; 3840 } 3841 case 16: { 3842 Port = input.ReadInt32(); 3843 break; 3844 } 3845 case 24: { 3846 Cores = input.ReadInt32(); 3847 break; 3848 } 3849 } 3850 } 3851 #endif 3852 } 3853 3854 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3855 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)3856 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 3857 uint tag; 3858 while ((tag = input.ReadTag()) != 0) { 3859 switch(tag) { 3860 default: 3861 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 3862 break; 3863 case 10: { 3864 if (stats_ == null) { 3865 Stats = new global::Grpc.Testing.ServerStats(); 3866 } 3867 input.ReadMessage(Stats); 3868 break; 3869 } 3870 case 16: { 3871 Port = input.ReadInt32(); 3872 break; 3873 } 3874 case 24: { 3875 Cores = input.ReadInt32(); 3876 break; 3877 } 3878 } 3879 } 3880 } 3881 #endif 3882 3883 } 3884 3885 public sealed partial class CoreRequest : pb::IMessage<CoreRequest> 3886 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3887 , pb::IBufferMessage 3888 #endif 3889 { 3890 private static readonly pb::MessageParser<CoreRequest> _parser = new pb::MessageParser<CoreRequest>(() => new CoreRequest()); 3891 private pb::UnknownFieldSet _unknownFields; 3892 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3893 public static pb::MessageParser<CoreRequest> Parser { get { return _parser; } } 3894 3895 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3896 public static pbr::MessageDescriptor Descriptor { 3897 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[12]; } 3898 } 3899 3900 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3901 pbr::MessageDescriptor pb::IMessage.Descriptor { 3902 get { return Descriptor; } 3903 } 3904 3905 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CoreRequest()3906 public CoreRequest() { 3907 OnConstruction(); 3908 } 3909 OnConstruction()3910 partial void OnConstruction(); 3911 3912 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CoreRequest(CoreRequest other)3913 public CoreRequest(CoreRequest other) : this() { 3914 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 3915 } 3916 3917 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()3918 public CoreRequest Clone() { 3919 return new CoreRequest(this); 3920 } 3921 3922 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)3923 public override bool Equals(object other) { 3924 return Equals(other as CoreRequest); 3925 } 3926 3927 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(CoreRequest other)3928 public bool Equals(CoreRequest other) { 3929 if (ReferenceEquals(other, null)) { 3930 return false; 3931 } 3932 if (ReferenceEquals(other, this)) { 3933 return true; 3934 } 3935 return Equals(_unknownFields, other._unknownFields); 3936 } 3937 3938 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()3939 public override int GetHashCode() { 3940 int hash = 1; 3941 if (_unknownFields != null) { 3942 hash ^= _unknownFields.GetHashCode(); 3943 } 3944 return hash; 3945 } 3946 3947 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()3948 public override string ToString() { 3949 return pb::JsonFormatter.ToDiagnosticString(this); 3950 } 3951 3952 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)3953 public void WriteTo(pb::CodedOutputStream output) { 3954 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3955 output.WriteRawMessage(this); 3956 #else 3957 if (_unknownFields != null) { 3958 _unknownFields.WriteTo(output); 3959 } 3960 #endif 3961 } 3962 3963 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3964 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)3965 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 3966 if (_unknownFields != null) { 3967 _unknownFields.WriteTo(ref output); 3968 } 3969 } 3970 #endif 3971 3972 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()3973 public int CalculateSize() { 3974 int size = 0; 3975 if (_unknownFields != null) { 3976 size += _unknownFields.CalculateSize(); 3977 } 3978 return size; 3979 } 3980 3981 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(CoreRequest other)3982 public void MergeFrom(CoreRequest other) { 3983 if (other == null) { 3984 return; 3985 } 3986 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3987 } 3988 3989 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3990 public void MergeFrom(pb::CodedInputStream input) { 3991 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 3992 input.ReadRawMessage(this); 3993 #else 3994 uint tag; 3995 while ((tag = input.ReadTag()) != 0) { 3996 switch(tag) { 3997 default: 3998 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3999 break; 4000 } 4001 } 4002 #endif 4003 } 4004 4005 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4006 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)4007 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 4008 uint tag; 4009 while ((tag = input.ReadTag()) != 0) { 4010 switch(tag) { 4011 default: 4012 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 4013 break; 4014 } 4015 } 4016 } 4017 #endif 4018 4019 } 4020 4021 public sealed partial class CoreResponse : pb::IMessage<CoreResponse> 4022 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4023 , pb::IBufferMessage 4024 #endif 4025 { 4026 private static readonly pb::MessageParser<CoreResponse> _parser = new pb::MessageParser<CoreResponse>(() => new CoreResponse()); 4027 private pb::UnknownFieldSet _unknownFields; 4028 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4029 public static pb::MessageParser<CoreResponse> Parser { get { return _parser; } } 4030 4031 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4032 public static pbr::MessageDescriptor Descriptor { 4033 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[13]; } 4034 } 4035 4036 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4037 pbr::MessageDescriptor pb::IMessage.Descriptor { 4038 get { return Descriptor; } 4039 } 4040 4041 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CoreResponse()4042 public CoreResponse() { 4043 OnConstruction(); 4044 } 4045 OnConstruction()4046 partial void OnConstruction(); 4047 4048 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CoreResponse(CoreResponse other)4049 public CoreResponse(CoreResponse other) : this() { 4050 cores_ = other.cores_; 4051 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 4052 } 4053 4054 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()4055 public CoreResponse Clone() { 4056 return new CoreResponse(this); 4057 } 4058 4059 /// <summary>Field number for the "cores" field.</summary> 4060 public const int CoresFieldNumber = 1; 4061 private int cores_; 4062 /// <summary> 4063 /// Number of cores available on the server 4064 /// </summary> 4065 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4066 public int Cores { 4067 get { return cores_; } 4068 set { 4069 cores_ = value; 4070 } 4071 } 4072 4073 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)4074 public override bool Equals(object other) { 4075 return Equals(other as CoreResponse); 4076 } 4077 4078 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(CoreResponse other)4079 public bool Equals(CoreResponse other) { 4080 if (ReferenceEquals(other, null)) { 4081 return false; 4082 } 4083 if (ReferenceEquals(other, this)) { 4084 return true; 4085 } 4086 if (Cores != other.Cores) return false; 4087 return Equals(_unknownFields, other._unknownFields); 4088 } 4089 4090 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()4091 public override int GetHashCode() { 4092 int hash = 1; 4093 if (Cores != 0) hash ^= Cores.GetHashCode(); 4094 if (_unknownFields != null) { 4095 hash ^= _unknownFields.GetHashCode(); 4096 } 4097 return hash; 4098 } 4099 4100 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()4101 public override string ToString() { 4102 return pb::JsonFormatter.ToDiagnosticString(this); 4103 } 4104 4105 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)4106 public void WriteTo(pb::CodedOutputStream output) { 4107 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4108 output.WriteRawMessage(this); 4109 #else 4110 if (Cores != 0) { 4111 output.WriteRawTag(8); 4112 output.WriteInt32(Cores); 4113 } 4114 if (_unknownFields != null) { 4115 _unknownFields.WriteTo(output); 4116 } 4117 #endif 4118 } 4119 4120 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4121 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)4122 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 4123 if (Cores != 0) { 4124 output.WriteRawTag(8); 4125 output.WriteInt32(Cores); 4126 } 4127 if (_unknownFields != null) { 4128 _unknownFields.WriteTo(ref output); 4129 } 4130 } 4131 #endif 4132 4133 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()4134 public int CalculateSize() { 4135 int size = 0; 4136 if (Cores != 0) { 4137 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Cores); 4138 } 4139 if (_unknownFields != null) { 4140 size += _unknownFields.CalculateSize(); 4141 } 4142 return size; 4143 } 4144 4145 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(CoreResponse other)4146 public void MergeFrom(CoreResponse other) { 4147 if (other == null) { 4148 return; 4149 } 4150 if (other.Cores != 0) { 4151 Cores = other.Cores; 4152 } 4153 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 4154 } 4155 4156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)4157 public void MergeFrom(pb::CodedInputStream input) { 4158 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4159 input.ReadRawMessage(this); 4160 #else 4161 uint tag; 4162 while ((tag = input.ReadTag()) != 0) { 4163 switch(tag) { 4164 default: 4165 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 4166 break; 4167 case 8: { 4168 Cores = input.ReadInt32(); 4169 break; 4170 } 4171 } 4172 } 4173 #endif 4174 } 4175 4176 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4177 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)4178 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 4179 uint tag; 4180 while ((tag = input.ReadTag()) != 0) { 4181 switch(tag) { 4182 default: 4183 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 4184 break; 4185 case 8: { 4186 Cores = input.ReadInt32(); 4187 break; 4188 } 4189 } 4190 } 4191 } 4192 #endif 4193 4194 } 4195 4196 public sealed partial class Void : pb::IMessage<Void> 4197 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4198 , pb::IBufferMessage 4199 #endif 4200 { 4201 private static readonly pb::MessageParser<Void> _parser = new pb::MessageParser<Void>(() => new Void()); 4202 private pb::UnknownFieldSet _unknownFields; 4203 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4204 public static pb::MessageParser<Void> Parser { get { return _parser; } } 4205 4206 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4207 public static pbr::MessageDescriptor Descriptor { 4208 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[14]; } 4209 } 4210 4211 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4212 pbr::MessageDescriptor pb::IMessage.Descriptor { 4213 get { return Descriptor; } 4214 } 4215 4216 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Void()4217 public Void() { 4218 OnConstruction(); 4219 } 4220 OnConstruction()4221 partial void OnConstruction(); 4222 4223 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Void(Void other)4224 public Void(Void other) : this() { 4225 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 4226 } 4227 4228 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()4229 public Void Clone() { 4230 return new Void(this); 4231 } 4232 4233 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)4234 public override bool Equals(object other) { 4235 return Equals(other as Void); 4236 } 4237 4238 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(Void other)4239 public bool Equals(Void other) { 4240 if (ReferenceEquals(other, null)) { 4241 return false; 4242 } 4243 if (ReferenceEquals(other, this)) { 4244 return true; 4245 } 4246 return Equals(_unknownFields, other._unknownFields); 4247 } 4248 4249 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()4250 public override int GetHashCode() { 4251 int hash = 1; 4252 if (_unknownFields != null) { 4253 hash ^= _unknownFields.GetHashCode(); 4254 } 4255 return hash; 4256 } 4257 4258 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()4259 public override string ToString() { 4260 return pb::JsonFormatter.ToDiagnosticString(this); 4261 } 4262 4263 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)4264 public void WriteTo(pb::CodedOutputStream output) { 4265 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4266 output.WriteRawMessage(this); 4267 #else 4268 if (_unknownFields != null) { 4269 _unknownFields.WriteTo(output); 4270 } 4271 #endif 4272 } 4273 4274 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4275 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)4276 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 4277 if (_unknownFields != null) { 4278 _unknownFields.WriteTo(ref output); 4279 } 4280 } 4281 #endif 4282 4283 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()4284 public int CalculateSize() { 4285 int size = 0; 4286 if (_unknownFields != null) { 4287 size += _unknownFields.CalculateSize(); 4288 } 4289 return size; 4290 } 4291 4292 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(Void other)4293 public void MergeFrom(Void other) { 4294 if (other == null) { 4295 return; 4296 } 4297 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 4298 } 4299 4300 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)4301 public void MergeFrom(pb::CodedInputStream input) { 4302 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4303 input.ReadRawMessage(this); 4304 #else 4305 uint tag; 4306 while ((tag = input.ReadTag()) != 0) { 4307 switch(tag) { 4308 default: 4309 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 4310 break; 4311 } 4312 } 4313 #endif 4314 } 4315 4316 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4317 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)4318 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 4319 uint tag; 4320 while ((tag = input.ReadTag()) != 0) { 4321 switch(tag) { 4322 default: 4323 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 4324 break; 4325 } 4326 } 4327 } 4328 #endif 4329 4330 } 4331 4332 /// <summary> 4333 /// A single performance scenario: input to qps_json_driver 4334 /// </summary> 4335 public sealed partial class Scenario : pb::IMessage<Scenario> 4336 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4337 , pb::IBufferMessage 4338 #endif 4339 { 4340 private static readonly pb::MessageParser<Scenario> _parser = new pb::MessageParser<Scenario>(() => new Scenario()); 4341 private pb::UnknownFieldSet _unknownFields; 4342 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4343 public static pb::MessageParser<Scenario> Parser { get { return _parser; } } 4344 4345 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4346 public static pbr::MessageDescriptor Descriptor { 4347 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[15]; } 4348 } 4349 4350 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4351 pbr::MessageDescriptor pb::IMessage.Descriptor { 4352 get { return Descriptor; } 4353 } 4354 4355 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Scenario()4356 public Scenario() { 4357 OnConstruction(); 4358 } 4359 OnConstruction()4360 partial void OnConstruction(); 4361 4362 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Scenario(Scenario other)4363 public Scenario(Scenario other) : this() { 4364 name_ = other.name_; 4365 clientConfig_ = other.clientConfig_ != null ? other.clientConfig_.Clone() : null; 4366 numClients_ = other.numClients_; 4367 serverConfig_ = other.serverConfig_ != null ? other.serverConfig_.Clone() : null; 4368 numServers_ = other.numServers_; 4369 warmupSeconds_ = other.warmupSeconds_; 4370 benchmarkSeconds_ = other.benchmarkSeconds_; 4371 spawnLocalWorkerCount_ = other.spawnLocalWorkerCount_; 4372 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 4373 } 4374 4375 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()4376 public Scenario Clone() { 4377 return new Scenario(this); 4378 } 4379 4380 /// <summary>Field number for the "name" field.</summary> 4381 public const int NameFieldNumber = 1; 4382 private string name_ = ""; 4383 /// <summary> 4384 /// Human readable name for this scenario 4385 /// </summary> 4386 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4387 public string Name { 4388 get { return name_; } 4389 set { 4390 name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 4391 } 4392 } 4393 4394 /// <summary>Field number for the "client_config" field.</summary> 4395 public const int ClientConfigFieldNumber = 2; 4396 private global::Grpc.Testing.ClientConfig clientConfig_; 4397 /// <summary> 4398 /// Client configuration 4399 /// </summary> 4400 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4401 public global::Grpc.Testing.ClientConfig ClientConfig { 4402 get { return clientConfig_; } 4403 set { 4404 clientConfig_ = value; 4405 } 4406 } 4407 4408 /// <summary>Field number for the "num_clients" field.</summary> 4409 public const int NumClientsFieldNumber = 3; 4410 private int numClients_; 4411 /// <summary> 4412 /// Number of clients to start for the test 4413 /// </summary> 4414 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4415 public int NumClients { 4416 get { return numClients_; } 4417 set { 4418 numClients_ = value; 4419 } 4420 } 4421 4422 /// <summary>Field number for the "server_config" field.</summary> 4423 public const int ServerConfigFieldNumber = 4; 4424 private global::Grpc.Testing.ServerConfig serverConfig_; 4425 /// <summary> 4426 /// Server configuration 4427 /// </summary> 4428 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4429 public global::Grpc.Testing.ServerConfig ServerConfig { 4430 get { return serverConfig_; } 4431 set { 4432 serverConfig_ = value; 4433 } 4434 } 4435 4436 /// <summary>Field number for the "num_servers" field.</summary> 4437 public const int NumServersFieldNumber = 5; 4438 private int numServers_; 4439 /// <summary> 4440 /// Number of servers to start for the test 4441 /// </summary> 4442 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4443 public int NumServers { 4444 get { return numServers_; } 4445 set { 4446 numServers_ = value; 4447 } 4448 } 4449 4450 /// <summary>Field number for the "warmup_seconds" field.</summary> 4451 public const int WarmupSecondsFieldNumber = 6; 4452 private int warmupSeconds_; 4453 /// <summary> 4454 /// Warmup period, in seconds 4455 /// </summary> 4456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4457 public int WarmupSeconds { 4458 get { return warmupSeconds_; } 4459 set { 4460 warmupSeconds_ = value; 4461 } 4462 } 4463 4464 /// <summary>Field number for the "benchmark_seconds" field.</summary> 4465 public const int BenchmarkSecondsFieldNumber = 7; 4466 private int benchmarkSeconds_; 4467 /// <summary> 4468 /// Benchmark time, in seconds 4469 /// </summary> 4470 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4471 public int BenchmarkSeconds { 4472 get { return benchmarkSeconds_; } 4473 set { 4474 benchmarkSeconds_ = value; 4475 } 4476 } 4477 4478 /// <summary>Field number for the "spawn_local_worker_count" field.</summary> 4479 public const int SpawnLocalWorkerCountFieldNumber = 8; 4480 private int spawnLocalWorkerCount_; 4481 /// <summary> 4482 /// Number of workers to spawn locally (usually zero) 4483 /// </summary> 4484 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4485 public int SpawnLocalWorkerCount { 4486 get { return spawnLocalWorkerCount_; } 4487 set { 4488 spawnLocalWorkerCount_ = value; 4489 } 4490 } 4491 4492 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)4493 public override bool Equals(object other) { 4494 return Equals(other as Scenario); 4495 } 4496 4497 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(Scenario other)4498 public bool Equals(Scenario other) { 4499 if (ReferenceEquals(other, null)) { 4500 return false; 4501 } 4502 if (ReferenceEquals(other, this)) { 4503 return true; 4504 } 4505 if (Name != other.Name) return false; 4506 if (!object.Equals(ClientConfig, other.ClientConfig)) return false; 4507 if (NumClients != other.NumClients) return false; 4508 if (!object.Equals(ServerConfig, other.ServerConfig)) return false; 4509 if (NumServers != other.NumServers) return false; 4510 if (WarmupSeconds != other.WarmupSeconds) return false; 4511 if (BenchmarkSeconds != other.BenchmarkSeconds) return false; 4512 if (SpawnLocalWorkerCount != other.SpawnLocalWorkerCount) return false; 4513 return Equals(_unknownFields, other._unknownFields); 4514 } 4515 4516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()4517 public override int GetHashCode() { 4518 int hash = 1; 4519 if (Name.Length != 0) hash ^= Name.GetHashCode(); 4520 if (clientConfig_ != null) hash ^= ClientConfig.GetHashCode(); 4521 if (NumClients != 0) hash ^= NumClients.GetHashCode(); 4522 if (serverConfig_ != null) hash ^= ServerConfig.GetHashCode(); 4523 if (NumServers != 0) hash ^= NumServers.GetHashCode(); 4524 if (WarmupSeconds != 0) hash ^= WarmupSeconds.GetHashCode(); 4525 if (BenchmarkSeconds != 0) hash ^= BenchmarkSeconds.GetHashCode(); 4526 if (SpawnLocalWorkerCount != 0) hash ^= SpawnLocalWorkerCount.GetHashCode(); 4527 if (_unknownFields != null) { 4528 hash ^= _unknownFields.GetHashCode(); 4529 } 4530 return hash; 4531 } 4532 4533 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()4534 public override string ToString() { 4535 return pb::JsonFormatter.ToDiagnosticString(this); 4536 } 4537 4538 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)4539 public void WriteTo(pb::CodedOutputStream output) { 4540 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4541 output.WriteRawMessage(this); 4542 #else 4543 if (Name.Length != 0) { 4544 output.WriteRawTag(10); 4545 output.WriteString(Name); 4546 } 4547 if (clientConfig_ != null) { 4548 output.WriteRawTag(18); 4549 output.WriteMessage(ClientConfig); 4550 } 4551 if (NumClients != 0) { 4552 output.WriteRawTag(24); 4553 output.WriteInt32(NumClients); 4554 } 4555 if (serverConfig_ != null) { 4556 output.WriteRawTag(34); 4557 output.WriteMessage(ServerConfig); 4558 } 4559 if (NumServers != 0) { 4560 output.WriteRawTag(40); 4561 output.WriteInt32(NumServers); 4562 } 4563 if (WarmupSeconds != 0) { 4564 output.WriteRawTag(48); 4565 output.WriteInt32(WarmupSeconds); 4566 } 4567 if (BenchmarkSeconds != 0) { 4568 output.WriteRawTag(56); 4569 output.WriteInt32(BenchmarkSeconds); 4570 } 4571 if (SpawnLocalWorkerCount != 0) { 4572 output.WriteRawTag(64); 4573 output.WriteInt32(SpawnLocalWorkerCount); 4574 } 4575 if (_unknownFields != null) { 4576 _unknownFields.WriteTo(output); 4577 } 4578 #endif 4579 } 4580 4581 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4582 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)4583 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 4584 if (Name.Length != 0) { 4585 output.WriteRawTag(10); 4586 output.WriteString(Name); 4587 } 4588 if (clientConfig_ != null) { 4589 output.WriteRawTag(18); 4590 output.WriteMessage(ClientConfig); 4591 } 4592 if (NumClients != 0) { 4593 output.WriteRawTag(24); 4594 output.WriteInt32(NumClients); 4595 } 4596 if (serverConfig_ != null) { 4597 output.WriteRawTag(34); 4598 output.WriteMessage(ServerConfig); 4599 } 4600 if (NumServers != 0) { 4601 output.WriteRawTag(40); 4602 output.WriteInt32(NumServers); 4603 } 4604 if (WarmupSeconds != 0) { 4605 output.WriteRawTag(48); 4606 output.WriteInt32(WarmupSeconds); 4607 } 4608 if (BenchmarkSeconds != 0) { 4609 output.WriteRawTag(56); 4610 output.WriteInt32(BenchmarkSeconds); 4611 } 4612 if (SpawnLocalWorkerCount != 0) { 4613 output.WriteRawTag(64); 4614 output.WriteInt32(SpawnLocalWorkerCount); 4615 } 4616 if (_unknownFields != null) { 4617 _unknownFields.WriteTo(ref output); 4618 } 4619 } 4620 #endif 4621 4622 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()4623 public int CalculateSize() { 4624 int size = 0; 4625 if (Name.Length != 0) { 4626 size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); 4627 } 4628 if (clientConfig_ != null) { 4629 size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClientConfig); 4630 } 4631 if (NumClients != 0) { 4632 size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumClients); 4633 } 4634 if (serverConfig_ != null) { 4635 size += 1 + pb::CodedOutputStream.ComputeMessageSize(ServerConfig); 4636 } 4637 if (NumServers != 0) { 4638 size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumServers); 4639 } 4640 if (WarmupSeconds != 0) { 4641 size += 1 + pb::CodedOutputStream.ComputeInt32Size(WarmupSeconds); 4642 } 4643 if (BenchmarkSeconds != 0) { 4644 size += 1 + pb::CodedOutputStream.ComputeInt32Size(BenchmarkSeconds); 4645 } 4646 if (SpawnLocalWorkerCount != 0) { 4647 size += 1 + pb::CodedOutputStream.ComputeInt32Size(SpawnLocalWorkerCount); 4648 } 4649 if (_unknownFields != null) { 4650 size += _unknownFields.CalculateSize(); 4651 } 4652 return size; 4653 } 4654 4655 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(Scenario other)4656 public void MergeFrom(Scenario other) { 4657 if (other == null) { 4658 return; 4659 } 4660 if (other.Name.Length != 0) { 4661 Name = other.Name; 4662 } 4663 if (other.clientConfig_ != null) { 4664 if (clientConfig_ == null) { 4665 ClientConfig = new global::Grpc.Testing.ClientConfig(); 4666 } 4667 ClientConfig.MergeFrom(other.ClientConfig); 4668 } 4669 if (other.NumClients != 0) { 4670 NumClients = other.NumClients; 4671 } 4672 if (other.serverConfig_ != null) { 4673 if (serverConfig_ == null) { 4674 ServerConfig = new global::Grpc.Testing.ServerConfig(); 4675 } 4676 ServerConfig.MergeFrom(other.ServerConfig); 4677 } 4678 if (other.NumServers != 0) { 4679 NumServers = other.NumServers; 4680 } 4681 if (other.WarmupSeconds != 0) { 4682 WarmupSeconds = other.WarmupSeconds; 4683 } 4684 if (other.BenchmarkSeconds != 0) { 4685 BenchmarkSeconds = other.BenchmarkSeconds; 4686 } 4687 if (other.SpawnLocalWorkerCount != 0) { 4688 SpawnLocalWorkerCount = other.SpawnLocalWorkerCount; 4689 } 4690 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 4691 } 4692 4693 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)4694 public void MergeFrom(pb::CodedInputStream input) { 4695 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4696 input.ReadRawMessage(this); 4697 #else 4698 uint tag; 4699 while ((tag = input.ReadTag()) != 0) { 4700 switch(tag) { 4701 default: 4702 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 4703 break; 4704 case 10: { 4705 Name = input.ReadString(); 4706 break; 4707 } 4708 case 18: { 4709 if (clientConfig_ == null) { 4710 ClientConfig = new global::Grpc.Testing.ClientConfig(); 4711 } 4712 input.ReadMessage(ClientConfig); 4713 break; 4714 } 4715 case 24: { 4716 NumClients = input.ReadInt32(); 4717 break; 4718 } 4719 case 34: { 4720 if (serverConfig_ == null) { 4721 ServerConfig = new global::Grpc.Testing.ServerConfig(); 4722 } 4723 input.ReadMessage(ServerConfig); 4724 break; 4725 } 4726 case 40: { 4727 NumServers = input.ReadInt32(); 4728 break; 4729 } 4730 case 48: { 4731 WarmupSeconds = input.ReadInt32(); 4732 break; 4733 } 4734 case 56: { 4735 BenchmarkSeconds = input.ReadInt32(); 4736 break; 4737 } 4738 case 64: { 4739 SpawnLocalWorkerCount = input.ReadInt32(); 4740 break; 4741 } 4742 } 4743 } 4744 #endif 4745 } 4746 4747 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4748 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)4749 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 4750 uint tag; 4751 while ((tag = input.ReadTag()) != 0) { 4752 switch(tag) { 4753 default: 4754 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 4755 break; 4756 case 10: { 4757 Name = input.ReadString(); 4758 break; 4759 } 4760 case 18: { 4761 if (clientConfig_ == null) { 4762 ClientConfig = new global::Grpc.Testing.ClientConfig(); 4763 } 4764 input.ReadMessage(ClientConfig); 4765 break; 4766 } 4767 case 24: { 4768 NumClients = input.ReadInt32(); 4769 break; 4770 } 4771 case 34: { 4772 if (serverConfig_ == null) { 4773 ServerConfig = new global::Grpc.Testing.ServerConfig(); 4774 } 4775 input.ReadMessage(ServerConfig); 4776 break; 4777 } 4778 case 40: { 4779 NumServers = input.ReadInt32(); 4780 break; 4781 } 4782 case 48: { 4783 WarmupSeconds = input.ReadInt32(); 4784 break; 4785 } 4786 case 56: { 4787 BenchmarkSeconds = input.ReadInt32(); 4788 break; 4789 } 4790 case 64: { 4791 SpawnLocalWorkerCount = input.ReadInt32(); 4792 break; 4793 } 4794 } 4795 } 4796 } 4797 #endif 4798 4799 } 4800 4801 /// <summary> 4802 /// A set of scenarios to be run with qps_json_driver 4803 /// </summary> 4804 public sealed partial class Scenarios : pb::IMessage<Scenarios> 4805 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4806 , pb::IBufferMessage 4807 #endif 4808 { 4809 private static readonly pb::MessageParser<Scenarios> _parser = new pb::MessageParser<Scenarios>(() => new Scenarios()); 4810 private pb::UnknownFieldSet _unknownFields; 4811 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4812 public static pb::MessageParser<Scenarios> Parser { get { return _parser; } } 4813 4814 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4815 public static pbr::MessageDescriptor Descriptor { 4816 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[16]; } 4817 } 4818 4819 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4820 pbr::MessageDescriptor pb::IMessage.Descriptor { 4821 get { return Descriptor; } 4822 } 4823 4824 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Scenarios()4825 public Scenarios() { 4826 OnConstruction(); 4827 } 4828 OnConstruction()4829 partial void OnConstruction(); 4830 4831 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Scenarios(Scenarios other)4832 public Scenarios(Scenarios other) : this() { 4833 scenarios_ = other.scenarios_.Clone(); 4834 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 4835 } 4836 4837 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()4838 public Scenarios Clone() { 4839 return new Scenarios(this); 4840 } 4841 4842 /// <summary>Field number for the "scenarios" field.</summary> 4843 public const int Scenarios_FieldNumber = 1; 4844 private static readonly pb::FieldCodec<global::Grpc.Testing.Scenario> _repeated_scenarios_codec 4845 = pb::FieldCodec.ForMessage(10, global::Grpc.Testing.Scenario.Parser); 4846 private readonly pbc::RepeatedField<global::Grpc.Testing.Scenario> scenarios_ = new pbc::RepeatedField<global::Grpc.Testing.Scenario>(); 4847 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4848 public pbc::RepeatedField<global::Grpc.Testing.Scenario> Scenarios_ { 4849 get { return scenarios_; } 4850 } 4851 4852 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)4853 public override bool Equals(object other) { 4854 return Equals(other as Scenarios); 4855 } 4856 4857 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(Scenarios other)4858 public bool Equals(Scenarios other) { 4859 if (ReferenceEquals(other, null)) { 4860 return false; 4861 } 4862 if (ReferenceEquals(other, this)) { 4863 return true; 4864 } 4865 if(!scenarios_.Equals(other.scenarios_)) return false; 4866 return Equals(_unknownFields, other._unknownFields); 4867 } 4868 4869 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()4870 public override int GetHashCode() { 4871 int hash = 1; 4872 hash ^= scenarios_.GetHashCode(); 4873 if (_unknownFields != null) { 4874 hash ^= _unknownFields.GetHashCode(); 4875 } 4876 return hash; 4877 } 4878 4879 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()4880 public override string ToString() { 4881 return pb::JsonFormatter.ToDiagnosticString(this); 4882 } 4883 4884 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)4885 public void WriteTo(pb::CodedOutputStream output) { 4886 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4887 output.WriteRawMessage(this); 4888 #else 4889 scenarios_.WriteTo(output, _repeated_scenarios_codec); 4890 if (_unknownFields != null) { 4891 _unknownFields.WriteTo(output); 4892 } 4893 #endif 4894 } 4895 4896 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4897 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)4898 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 4899 scenarios_.WriteTo(ref output, _repeated_scenarios_codec); 4900 if (_unknownFields != null) { 4901 _unknownFields.WriteTo(ref output); 4902 } 4903 } 4904 #endif 4905 4906 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()4907 public int CalculateSize() { 4908 int size = 0; 4909 size += scenarios_.CalculateSize(_repeated_scenarios_codec); 4910 if (_unknownFields != null) { 4911 size += _unknownFields.CalculateSize(); 4912 } 4913 return size; 4914 } 4915 4916 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(Scenarios other)4917 public void MergeFrom(Scenarios other) { 4918 if (other == null) { 4919 return; 4920 } 4921 scenarios_.Add(other.scenarios_); 4922 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 4923 } 4924 4925 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)4926 public void MergeFrom(pb::CodedInputStream input) { 4927 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4928 input.ReadRawMessage(this); 4929 #else 4930 uint tag; 4931 while ((tag = input.ReadTag()) != 0) { 4932 switch(tag) { 4933 default: 4934 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 4935 break; 4936 case 10: { 4937 scenarios_.AddEntriesFrom(input, _repeated_scenarios_codec); 4938 break; 4939 } 4940 } 4941 } 4942 #endif 4943 } 4944 4945 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4946 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)4947 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 4948 uint tag; 4949 while ((tag = input.ReadTag()) != 0) { 4950 switch(tag) { 4951 default: 4952 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 4953 break; 4954 case 10: { 4955 scenarios_.AddEntriesFrom(ref input, _repeated_scenarios_codec); 4956 break; 4957 } 4958 } 4959 } 4960 } 4961 #endif 4962 4963 } 4964 4965 /// <summary> 4966 /// Basic summary that can be computed from ClientStats and ServerStats 4967 /// once the scenario has finished. 4968 /// </summary> 4969 public sealed partial class ScenarioResultSummary : pb::IMessage<ScenarioResultSummary> 4970 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 4971 , pb::IBufferMessage 4972 #endif 4973 { 4974 private static readonly pb::MessageParser<ScenarioResultSummary> _parser = new pb::MessageParser<ScenarioResultSummary>(() => new ScenarioResultSummary()); 4975 private pb::UnknownFieldSet _unknownFields; 4976 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4977 public static pb::MessageParser<ScenarioResultSummary> Parser { get { return _parser; } } 4978 4979 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4980 public static pbr::MessageDescriptor Descriptor { 4981 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[17]; } 4982 } 4983 4984 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4985 pbr::MessageDescriptor pb::IMessage.Descriptor { 4986 get { return Descriptor; } 4987 } 4988 4989 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ScenarioResultSummary()4990 public ScenarioResultSummary() { 4991 OnConstruction(); 4992 } 4993 OnConstruction()4994 partial void OnConstruction(); 4995 4996 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ScenarioResultSummary(ScenarioResultSummary other)4997 public ScenarioResultSummary(ScenarioResultSummary other) : this() { 4998 qps_ = other.qps_; 4999 qpsPerServerCore_ = other.qpsPerServerCore_; 5000 serverSystemTime_ = other.serverSystemTime_; 5001 serverUserTime_ = other.serverUserTime_; 5002 clientSystemTime_ = other.clientSystemTime_; 5003 clientUserTime_ = other.clientUserTime_; 5004 latency50_ = other.latency50_; 5005 latency90_ = other.latency90_; 5006 latency95_ = other.latency95_; 5007 latency99_ = other.latency99_; 5008 latency999_ = other.latency999_; 5009 serverCpuUsage_ = other.serverCpuUsage_; 5010 successfulRequestsPerSecond_ = other.successfulRequestsPerSecond_; 5011 failedRequestsPerSecond_ = other.failedRequestsPerSecond_; 5012 clientPollsPerRequest_ = other.clientPollsPerRequest_; 5013 serverPollsPerRequest_ = other.serverPollsPerRequest_; 5014 serverQueriesPerCpuSec_ = other.serverQueriesPerCpuSec_; 5015 clientQueriesPerCpuSec_ = other.clientQueriesPerCpuSec_; 5016 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 5017 } 5018 5019 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()5020 public ScenarioResultSummary Clone() { 5021 return new ScenarioResultSummary(this); 5022 } 5023 5024 /// <summary>Field number for the "qps" field.</summary> 5025 public const int QpsFieldNumber = 1; 5026 private double qps_; 5027 /// <summary> 5028 /// Total number of operations per second over all clients. What is counted as 1 'operation' depends on the benchmark scenarios: 5029 /// For unary benchmarks, an operation is processing of a single unary RPC. 5030 /// For streaming benchmarks, an operation is processing of a single ping pong of request and response. 5031 /// </summary> 5032 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5033 public double Qps { 5034 get { return qps_; } 5035 set { 5036 qps_ = value; 5037 } 5038 } 5039 5040 /// <summary>Field number for the "qps_per_server_core" field.</summary> 5041 public const int QpsPerServerCoreFieldNumber = 2; 5042 private double qpsPerServerCore_; 5043 /// <summary> 5044 /// QPS per server core. 5045 /// </summary> 5046 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5047 public double QpsPerServerCore { 5048 get { return qpsPerServerCore_; } 5049 set { 5050 qpsPerServerCore_ = value; 5051 } 5052 } 5053 5054 /// <summary>Field number for the "server_system_time" field.</summary> 5055 public const int ServerSystemTimeFieldNumber = 3; 5056 private double serverSystemTime_; 5057 /// <summary> 5058 /// The total server cpu load based on system time across all server processes, expressed as percentage of a single cpu core. 5059 /// For example, 85 implies 85% of a cpu core, 125 implies 125% of a cpu core. Since we are accumulating the cpu load across all the server 5060 /// processes, the value could > 100 when there are multiple servers or a single server using multiple threads and cores. 5061 /// Same explanation for the total client cpu load below. 5062 /// </summary> 5063 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5064 public double ServerSystemTime { 5065 get { return serverSystemTime_; } 5066 set { 5067 serverSystemTime_ = value; 5068 } 5069 } 5070 5071 /// <summary>Field number for the "server_user_time" field.</summary> 5072 public const int ServerUserTimeFieldNumber = 4; 5073 private double serverUserTime_; 5074 /// <summary> 5075 /// The total server cpu load based on user time across all server processes, expressed as percentage of a single cpu core. (85 => 85%, 125 => 125%) 5076 /// </summary> 5077 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5078 public double ServerUserTime { 5079 get { return serverUserTime_; } 5080 set { 5081 serverUserTime_ = value; 5082 } 5083 } 5084 5085 /// <summary>Field number for the "client_system_time" field.</summary> 5086 public const int ClientSystemTimeFieldNumber = 5; 5087 private double clientSystemTime_; 5088 /// <summary> 5089 /// The total client cpu load based on system time across all client processes, expressed as percentage of a single cpu core. (85 => 85%, 125 => 125%) 5090 /// </summary> 5091 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5092 public double ClientSystemTime { 5093 get { return clientSystemTime_; } 5094 set { 5095 clientSystemTime_ = value; 5096 } 5097 } 5098 5099 /// <summary>Field number for the "client_user_time" field.</summary> 5100 public const int ClientUserTimeFieldNumber = 6; 5101 private double clientUserTime_; 5102 /// <summary> 5103 /// The total client cpu load based on user time across all client processes, expressed as percentage of a single cpu core. (85 => 85%, 125 => 125%) 5104 /// </summary> 5105 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5106 public double ClientUserTime { 5107 get { return clientUserTime_; } 5108 set { 5109 clientUserTime_ = value; 5110 } 5111 } 5112 5113 /// <summary>Field number for the "latency_50" field.</summary> 5114 public const int Latency50FieldNumber = 7; 5115 private double latency50_; 5116 /// <summary> 5117 /// X% latency percentiles (in nanoseconds) 5118 /// </summary> 5119 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5120 public double Latency50 { 5121 get { return latency50_; } 5122 set { 5123 latency50_ = value; 5124 } 5125 } 5126 5127 /// <summary>Field number for the "latency_90" field.</summary> 5128 public const int Latency90FieldNumber = 8; 5129 private double latency90_; 5130 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5131 public double Latency90 { 5132 get { return latency90_; } 5133 set { 5134 latency90_ = value; 5135 } 5136 } 5137 5138 /// <summary>Field number for the "latency_95" field.</summary> 5139 public const int Latency95FieldNumber = 9; 5140 private double latency95_; 5141 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5142 public double Latency95 { 5143 get { return latency95_; } 5144 set { 5145 latency95_ = value; 5146 } 5147 } 5148 5149 /// <summary>Field number for the "latency_99" field.</summary> 5150 public const int Latency99FieldNumber = 10; 5151 private double latency99_; 5152 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5153 public double Latency99 { 5154 get { return latency99_; } 5155 set { 5156 latency99_ = value; 5157 } 5158 } 5159 5160 /// <summary>Field number for the "latency_999" field.</summary> 5161 public const int Latency999FieldNumber = 11; 5162 private double latency999_; 5163 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5164 public double Latency999 { 5165 get { return latency999_; } 5166 set { 5167 latency999_ = value; 5168 } 5169 } 5170 5171 /// <summary>Field number for the "server_cpu_usage" field.</summary> 5172 public const int ServerCpuUsageFieldNumber = 12; 5173 private double serverCpuUsage_; 5174 /// <summary> 5175 /// server cpu usage percentage 5176 /// </summary> 5177 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5178 public double ServerCpuUsage { 5179 get { return serverCpuUsage_; } 5180 set { 5181 serverCpuUsage_ = value; 5182 } 5183 } 5184 5185 /// <summary>Field number for the "successful_requests_per_second" field.</summary> 5186 public const int SuccessfulRequestsPerSecondFieldNumber = 13; 5187 private double successfulRequestsPerSecond_; 5188 /// <summary> 5189 /// Number of requests that succeeded/failed 5190 /// </summary> 5191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5192 public double SuccessfulRequestsPerSecond { 5193 get { return successfulRequestsPerSecond_; } 5194 set { 5195 successfulRequestsPerSecond_ = value; 5196 } 5197 } 5198 5199 /// <summary>Field number for the "failed_requests_per_second" field.</summary> 5200 public const int FailedRequestsPerSecondFieldNumber = 14; 5201 private double failedRequestsPerSecond_; 5202 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5203 public double FailedRequestsPerSecond { 5204 get { return failedRequestsPerSecond_; } 5205 set { 5206 failedRequestsPerSecond_ = value; 5207 } 5208 } 5209 5210 /// <summary>Field number for the "client_polls_per_request" field.</summary> 5211 public const int ClientPollsPerRequestFieldNumber = 15; 5212 private double clientPollsPerRequest_; 5213 /// <summary> 5214 /// Number of polls called inside completion queue per request 5215 /// </summary> 5216 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5217 public double ClientPollsPerRequest { 5218 get { return clientPollsPerRequest_; } 5219 set { 5220 clientPollsPerRequest_ = value; 5221 } 5222 } 5223 5224 /// <summary>Field number for the "server_polls_per_request" field.</summary> 5225 public const int ServerPollsPerRequestFieldNumber = 16; 5226 private double serverPollsPerRequest_; 5227 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5228 public double ServerPollsPerRequest { 5229 get { return serverPollsPerRequest_; } 5230 set { 5231 serverPollsPerRequest_ = value; 5232 } 5233 } 5234 5235 /// <summary>Field number for the "server_queries_per_cpu_sec" field.</summary> 5236 public const int ServerQueriesPerCpuSecFieldNumber = 17; 5237 private double serverQueriesPerCpuSec_; 5238 /// <summary> 5239 /// Queries per CPU-sec over all servers or clients 5240 /// </summary> 5241 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5242 public double ServerQueriesPerCpuSec { 5243 get { return serverQueriesPerCpuSec_; } 5244 set { 5245 serverQueriesPerCpuSec_ = value; 5246 } 5247 } 5248 5249 /// <summary>Field number for the "client_queries_per_cpu_sec" field.</summary> 5250 public const int ClientQueriesPerCpuSecFieldNumber = 18; 5251 private double clientQueriesPerCpuSec_; 5252 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5253 public double ClientQueriesPerCpuSec { 5254 get { return clientQueriesPerCpuSec_; } 5255 set { 5256 clientQueriesPerCpuSec_ = value; 5257 } 5258 } 5259 5260 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)5261 public override bool Equals(object other) { 5262 return Equals(other as ScenarioResultSummary); 5263 } 5264 5265 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ScenarioResultSummary other)5266 public bool Equals(ScenarioResultSummary other) { 5267 if (ReferenceEquals(other, null)) { 5268 return false; 5269 } 5270 if (ReferenceEquals(other, this)) { 5271 return true; 5272 } 5273 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Qps, other.Qps)) return false; 5274 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(QpsPerServerCore, other.QpsPerServerCore)) return false; 5275 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerSystemTime, other.ServerSystemTime)) return false; 5276 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerUserTime, other.ServerUserTime)) return false; 5277 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClientSystemTime, other.ClientSystemTime)) return false; 5278 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClientUserTime, other.ClientUserTime)) return false; 5279 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency50, other.Latency50)) return false; 5280 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency90, other.Latency90)) return false; 5281 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency95, other.Latency95)) return false; 5282 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency99, other.Latency99)) return false; 5283 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency999, other.Latency999)) return false; 5284 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerCpuUsage, other.ServerCpuUsage)) return false; 5285 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SuccessfulRequestsPerSecond, other.SuccessfulRequestsPerSecond)) return false; 5286 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(FailedRequestsPerSecond, other.FailedRequestsPerSecond)) return false; 5287 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClientPollsPerRequest, other.ClientPollsPerRequest)) return false; 5288 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerPollsPerRequest, other.ServerPollsPerRequest)) return false; 5289 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerQueriesPerCpuSec, other.ServerQueriesPerCpuSec)) return false; 5290 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClientQueriesPerCpuSec, other.ClientQueriesPerCpuSec)) return false; 5291 return Equals(_unknownFields, other._unknownFields); 5292 } 5293 5294 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()5295 public override int GetHashCode() { 5296 int hash = 1; 5297 if (Qps != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Qps); 5298 if (QpsPerServerCore != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(QpsPerServerCore); 5299 if (ServerSystemTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerSystemTime); 5300 if (ServerUserTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerUserTime); 5301 if (ClientSystemTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClientSystemTime); 5302 if (ClientUserTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClientUserTime); 5303 if (Latency50 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency50); 5304 if (Latency90 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency90); 5305 if (Latency95 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency95); 5306 if (Latency99 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency99); 5307 if (Latency999 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency999); 5308 if (ServerCpuUsage != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerCpuUsage); 5309 if (SuccessfulRequestsPerSecond != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SuccessfulRequestsPerSecond); 5310 if (FailedRequestsPerSecond != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(FailedRequestsPerSecond); 5311 if (ClientPollsPerRequest != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClientPollsPerRequest); 5312 if (ServerPollsPerRequest != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerPollsPerRequest); 5313 if (ServerQueriesPerCpuSec != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerQueriesPerCpuSec); 5314 if (ClientQueriesPerCpuSec != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClientQueriesPerCpuSec); 5315 if (_unknownFields != null) { 5316 hash ^= _unknownFields.GetHashCode(); 5317 } 5318 return hash; 5319 } 5320 5321 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()5322 public override string ToString() { 5323 return pb::JsonFormatter.ToDiagnosticString(this); 5324 } 5325 5326 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)5327 public void WriteTo(pb::CodedOutputStream output) { 5328 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 5329 output.WriteRawMessage(this); 5330 #else 5331 if (Qps != 0D) { 5332 output.WriteRawTag(9); 5333 output.WriteDouble(Qps); 5334 } 5335 if (QpsPerServerCore != 0D) { 5336 output.WriteRawTag(17); 5337 output.WriteDouble(QpsPerServerCore); 5338 } 5339 if (ServerSystemTime != 0D) { 5340 output.WriteRawTag(25); 5341 output.WriteDouble(ServerSystemTime); 5342 } 5343 if (ServerUserTime != 0D) { 5344 output.WriteRawTag(33); 5345 output.WriteDouble(ServerUserTime); 5346 } 5347 if (ClientSystemTime != 0D) { 5348 output.WriteRawTag(41); 5349 output.WriteDouble(ClientSystemTime); 5350 } 5351 if (ClientUserTime != 0D) { 5352 output.WriteRawTag(49); 5353 output.WriteDouble(ClientUserTime); 5354 } 5355 if (Latency50 != 0D) { 5356 output.WriteRawTag(57); 5357 output.WriteDouble(Latency50); 5358 } 5359 if (Latency90 != 0D) { 5360 output.WriteRawTag(65); 5361 output.WriteDouble(Latency90); 5362 } 5363 if (Latency95 != 0D) { 5364 output.WriteRawTag(73); 5365 output.WriteDouble(Latency95); 5366 } 5367 if (Latency99 != 0D) { 5368 output.WriteRawTag(81); 5369 output.WriteDouble(Latency99); 5370 } 5371 if (Latency999 != 0D) { 5372 output.WriteRawTag(89); 5373 output.WriteDouble(Latency999); 5374 } 5375 if (ServerCpuUsage != 0D) { 5376 output.WriteRawTag(97); 5377 output.WriteDouble(ServerCpuUsage); 5378 } 5379 if (SuccessfulRequestsPerSecond != 0D) { 5380 output.WriteRawTag(105); 5381 output.WriteDouble(SuccessfulRequestsPerSecond); 5382 } 5383 if (FailedRequestsPerSecond != 0D) { 5384 output.WriteRawTag(113); 5385 output.WriteDouble(FailedRequestsPerSecond); 5386 } 5387 if (ClientPollsPerRequest != 0D) { 5388 output.WriteRawTag(121); 5389 output.WriteDouble(ClientPollsPerRequest); 5390 } 5391 if (ServerPollsPerRequest != 0D) { 5392 output.WriteRawTag(129, 1); 5393 output.WriteDouble(ServerPollsPerRequest); 5394 } 5395 if (ServerQueriesPerCpuSec != 0D) { 5396 output.WriteRawTag(137, 1); 5397 output.WriteDouble(ServerQueriesPerCpuSec); 5398 } 5399 if (ClientQueriesPerCpuSec != 0D) { 5400 output.WriteRawTag(145, 1); 5401 output.WriteDouble(ClientQueriesPerCpuSec); 5402 } 5403 if (_unknownFields != null) { 5404 _unknownFields.WriteTo(output); 5405 } 5406 #endif 5407 } 5408 5409 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 5410 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)5411 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 5412 if (Qps != 0D) { 5413 output.WriteRawTag(9); 5414 output.WriteDouble(Qps); 5415 } 5416 if (QpsPerServerCore != 0D) { 5417 output.WriteRawTag(17); 5418 output.WriteDouble(QpsPerServerCore); 5419 } 5420 if (ServerSystemTime != 0D) { 5421 output.WriteRawTag(25); 5422 output.WriteDouble(ServerSystemTime); 5423 } 5424 if (ServerUserTime != 0D) { 5425 output.WriteRawTag(33); 5426 output.WriteDouble(ServerUserTime); 5427 } 5428 if (ClientSystemTime != 0D) { 5429 output.WriteRawTag(41); 5430 output.WriteDouble(ClientSystemTime); 5431 } 5432 if (ClientUserTime != 0D) { 5433 output.WriteRawTag(49); 5434 output.WriteDouble(ClientUserTime); 5435 } 5436 if (Latency50 != 0D) { 5437 output.WriteRawTag(57); 5438 output.WriteDouble(Latency50); 5439 } 5440 if (Latency90 != 0D) { 5441 output.WriteRawTag(65); 5442 output.WriteDouble(Latency90); 5443 } 5444 if (Latency95 != 0D) { 5445 output.WriteRawTag(73); 5446 output.WriteDouble(Latency95); 5447 } 5448 if (Latency99 != 0D) { 5449 output.WriteRawTag(81); 5450 output.WriteDouble(Latency99); 5451 } 5452 if (Latency999 != 0D) { 5453 output.WriteRawTag(89); 5454 output.WriteDouble(Latency999); 5455 } 5456 if (ServerCpuUsage != 0D) { 5457 output.WriteRawTag(97); 5458 output.WriteDouble(ServerCpuUsage); 5459 } 5460 if (SuccessfulRequestsPerSecond != 0D) { 5461 output.WriteRawTag(105); 5462 output.WriteDouble(SuccessfulRequestsPerSecond); 5463 } 5464 if (FailedRequestsPerSecond != 0D) { 5465 output.WriteRawTag(113); 5466 output.WriteDouble(FailedRequestsPerSecond); 5467 } 5468 if (ClientPollsPerRequest != 0D) { 5469 output.WriteRawTag(121); 5470 output.WriteDouble(ClientPollsPerRequest); 5471 } 5472 if (ServerPollsPerRequest != 0D) { 5473 output.WriteRawTag(129, 1); 5474 output.WriteDouble(ServerPollsPerRequest); 5475 } 5476 if (ServerQueriesPerCpuSec != 0D) { 5477 output.WriteRawTag(137, 1); 5478 output.WriteDouble(ServerQueriesPerCpuSec); 5479 } 5480 if (ClientQueriesPerCpuSec != 0D) { 5481 output.WriteRawTag(145, 1); 5482 output.WriteDouble(ClientQueriesPerCpuSec); 5483 } 5484 if (_unknownFields != null) { 5485 _unknownFields.WriteTo(ref output); 5486 } 5487 } 5488 #endif 5489 5490 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()5491 public int CalculateSize() { 5492 int size = 0; 5493 if (Qps != 0D) { 5494 size += 1 + 8; 5495 } 5496 if (QpsPerServerCore != 0D) { 5497 size += 1 + 8; 5498 } 5499 if (ServerSystemTime != 0D) { 5500 size += 1 + 8; 5501 } 5502 if (ServerUserTime != 0D) { 5503 size += 1 + 8; 5504 } 5505 if (ClientSystemTime != 0D) { 5506 size += 1 + 8; 5507 } 5508 if (ClientUserTime != 0D) { 5509 size += 1 + 8; 5510 } 5511 if (Latency50 != 0D) { 5512 size += 1 + 8; 5513 } 5514 if (Latency90 != 0D) { 5515 size += 1 + 8; 5516 } 5517 if (Latency95 != 0D) { 5518 size += 1 + 8; 5519 } 5520 if (Latency99 != 0D) { 5521 size += 1 + 8; 5522 } 5523 if (Latency999 != 0D) { 5524 size += 1 + 8; 5525 } 5526 if (ServerCpuUsage != 0D) { 5527 size += 1 + 8; 5528 } 5529 if (SuccessfulRequestsPerSecond != 0D) { 5530 size += 1 + 8; 5531 } 5532 if (FailedRequestsPerSecond != 0D) { 5533 size += 1 + 8; 5534 } 5535 if (ClientPollsPerRequest != 0D) { 5536 size += 1 + 8; 5537 } 5538 if (ServerPollsPerRequest != 0D) { 5539 size += 2 + 8; 5540 } 5541 if (ServerQueriesPerCpuSec != 0D) { 5542 size += 2 + 8; 5543 } 5544 if (ClientQueriesPerCpuSec != 0D) { 5545 size += 2 + 8; 5546 } 5547 if (_unknownFields != null) { 5548 size += _unknownFields.CalculateSize(); 5549 } 5550 return size; 5551 } 5552 5553 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ScenarioResultSummary other)5554 public void MergeFrom(ScenarioResultSummary other) { 5555 if (other == null) { 5556 return; 5557 } 5558 if (other.Qps != 0D) { 5559 Qps = other.Qps; 5560 } 5561 if (other.QpsPerServerCore != 0D) { 5562 QpsPerServerCore = other.QpsPerServerCore; 5563 } 5564 if (other.ServerSystemTime != 0D) { 5565 ServerSystemTime = other.ServerSystemTime; 5566 } 5567 if (other.ServerUserTime != 0D) { 5568 ServerUserTime = other.ServerUserTime; 5569 } 5570 if (other.ClientSystemTime != 0D) { 5571 ClientSystemTime = other.ClientSystemTime; 5572 } 5573 if (other.ClientUserTime != 0D) { 5574 ClientUserTime = other.ClientUserTime; 5575 } 5576 if (other.Latency50 != 0D) { 5577 Latency50 = other.Latency50; 5578 } 5579 if (other.Latency90 != 0D) { 5580 Latency90 = other.Latency90; 5581 } 5582 if (other.Latency95 != 0D) { 5583 Latency95 = other.Latency95; 5584 } 5585 if (other.Latency99 != 0D) { 5586 Latency99 = other.Latency99; 5587 } 5588 if (other.Latency999 != 0D) { 5589 Latency999 = other.Latency999; 5590 } 5591 if (other.ServerCpuUsage != 0D) { 5592 ServerCpuUsage = other.ServerCpuUsage; 5593 } 5594 if (other.SuccessfulRequestsPerSecond != 0D) { 5595 SuccessfulRequestsPerSecond = other.SuccessfulRequestsPerSecond; 5596 } 5597 if (other.FailedRequestsPerSecond != 0D) { 5598 FailedRequestsPerSecond = other.FailedRequestsPerSecond; 5599 } 5600 if (other.ClientPollsPerRequest != 0D) { 5601 ClientPollsPerRequest = other.ClientPollsPerRequest; 5602 } 5603 if (other.ServerPollsPerRequest != 0D) { 5604 ServerPollsPerRequest = other.ServerPollsPerRequest; 5605 } 5606 if (other.ServerQueriesPerCpuSec != 0D) { 5607 ServerQueriesPerCpuSec = other.ServerQueriesPerCpuSec; 5608 } 5609 if (other.ClientQueriesPerCpuSec != 0D) { 5610 ClientQueriesPerCpuSec = other.ClientQueriesPerCpuSec; 5611 } 5612 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 5613 } 5614 5615 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)5616 public void MergeFrom(pb::CodedInputStream input) { 5617 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 5618 input.ReadRawMessage(this); 5619 #else 5620 uint tag; 5621 while ((tag = input.ReadTag()) != 0) { 5622 switch(tag) { 5623 default: 5624 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 5625 break; 5626 case 9: { 5627 Qps = input.ReadDouble(); 5628 break; 5629 } 5630 case 17: { 5631 QpsPerServerCore = input.ReadDouble(); 5632 break; 5633 } 5634 case 25: { 5635 ServerSystemTime = input.ReadDouble(); 5636 break; 5637 } 5638 case 33: { 5639 ServerUserTime = input.ReadDouble(); 5640 break; 5641 } 5642 case 41: { 5643 ClientSystemTime = input.ReadDouble(); 5644 break; 5645 } 5646 case 49: { 5647 ClientUserTime = input.ReadDouble(); 5648 break; 5649 } 5650 case 57: { 5651 Latency50 = input.ReadDouble(); 5652 break; 5653 } 5654 case 65: { 5655 Latency90 = input.ReadDouble(); 5656 break; 5657 } 5658 case 73: { 5659 Latency95 = input.ReadDouble(); 5660 break; 5661 } 5662 case 81: { 5663 Latency99 = input.ReadDouble(); 5664 break; 5665 } 5666 case 89: { 5667 Latency999 = input.ReadDouble(); 5668 break; 5669 } 5670 case 97: { 5671 ServerCpuUsage = input.ReadDouble(); 5672 break; 5673 } 5674 case 105: { 5675 SuccessfulRequestsPerSecond = input.ReadDouble(); 5676 break; 5677 } 5678 case 113: { 5679 FailedRequestsPerSecond = input.ReadDouble(); 5680 break; 5681 } 5682 case 121: { 5683 ClientPollsPerRequest = input.ReadDouble(); 5684 break; 5685 } 5686 case 129: { 5687 ServerPollsPerRequest = input.ReadDouble(); 5688 break; 5689 } 5690 case 137: { 5691 ServerQueriesPerCpuSec = input.ReadDouble(); 5692 break; 5693 } 5694 case 145: { 5695 ClientQueriesPerCpuSec = input.ReadDouble(); 5696 break; 5697 } 5698 } 5699 } 5700 #endif 5701 } 5702 5703 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 5704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)5705 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 5706 uint tag; 5707 while ((tag = input.ReadTag()) != 0) { 5708 switch(tag) { 5709 default: 5710 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 5711 break; 5712 case 9: { 5713 Qps = input.ReadDouble(); 5714 break; 5715 } 5716 case 17: { 5717 QpsPerServerCore = input.ReadDouble(); 5718 break; 5719 } 5720 case 25: { 5721 ServerSystemTime = input.ReadDouble(); 5722 break; 5723 } 5724 case 33: { 5725 ServerUserTime = input.ReadDouble(); 5726 break; 5727 } 5728 case 41: { 5729 ClientSystemTime = input.ReadDouble(); 5730 break; 5731 } 5732 case 49: { 5733 ClientUserTime = input.ReadDouble(); 5734 break; 5735 } 5736 case 57: { 5737 Latency50 = input.ReadDouble(); 5738 break; 5739 } 5740 case 65: { 5741 Latency90 = input.ReadDouble(); 5742 break; 5743 } 5744 case 73: { 5745 Latency95 = input.ReadDouble(); 5746 break; 5747 } 5748 case 81: { 5749 Latency99 = input.ReadDouble(); 5750 break; 5751 } 5752 case 89: { 5753 Latency999 = input.ReadDouble(); 5754 break; 5755 } 5756 case 97: { 5757 ServerCpuUsage = input.ReadDouble(); 5758 break; 5759 } 5760 case 105: { 5761 SuccessfulRequestsPerSecond = input.ReadDouble(); 5762 break; 5763 } 5764 case 113: { 5765 FailedRequestsPerSecond = input.ReadDouble(); 5766 break; 5767 } 5768 case 121: { 5769 ClientPollsPerRequest = input.ReadDouble(); 5770 break; 5771 } 5772 case 129: { 5773 ServerPollsPerRequest = input.ReadDouble(); 5774 break; 5775 } 5776 case 137: { 5777 ServerQueriesPerCpuSec = input.ReadDouble(); 5778 break; 5779 } 5780 case 145: { 5781 ClientQueriesPerCpuSec = input.ReadDouble(); 5782 break; 5783 } 5784 } 5785 } 5786 } 5787 #endif 5788 5789 } 5790 5791 /// <summary> 5792 /// Results of a single benchmark scenario. 5793 /// </summary> 5794 public sealed partial class ScenarioResult : pb::IMessage<ScenarioResult> 5795 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 5796 , pb::IBufferMessage 5797 #endif 5798 { 5799 private static readonly pb::MessageParser<ScenarioResult> _parser = new pb::MessageParser<ScenarioResult>(() => new ScenarioResult()); 5800 private pb::UnknownFieldSet _unknownFields; 5801 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5802 public static pb::MessageParser<ScenarioResult> Parser { get { return _parser; } } 5803 5804 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5805 public static pbr::MessageDescriptor Descriptor { 5806 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[18]; } 5807 } 5808 5809 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5810 pbr::MessageDescriptor pb::IMessage.Descriptor { 5811 get { return Descriptor; } 5812 } 5813 5814 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ScenarioResult()5815 public ScenarioResult() { 5816 OnConstruction(); 5817 } 5818 OnConstruction()5819 partial void OnConstruction(); 5820 5821 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ScenarioResult(ScenarioResult other)5822 public ScenarioResult(ScenarioResult other) : this() { 5823 scenario_ = other.scenario_ != null ? other.scenario_.Clone() : null; 5824 latencies_ = other.latencies_ != null ? other.latencies_.Clone() : null; 5825 clientStats_ = other.clientStats_.Clone(); 5826 serverStats_ = other.serverStats_.Clone(); 5827 serverCores_ = other.serverCores_.Clone(); 5828 summary_ = other.summary_ != null ? other.summary_.Clone() : null; 5829 clientSuccess_ = other.clientSuccess_.Clone(); 5830 serverSuccess_ = other.serverSuccess_.Clone(); 5831 requestResults_ = other.requestResults_.Clone(); 5832 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 5833 } 5834 5835 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()5836 public ScenarioResult Clone() { 5837 return new ScenarioResult(this); 5838 } 5839 5840 /// <summary>Field number for the "scenario" field.</summary> 5841 public const int ScenarioFieldNumber = 1; 5842 private global::Grpc.Testing.Scenario scenario_; 5843 /// <summary> 5844 /// Inputs used to run the scenario. 5845 /// </summary> 5846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5847 public global::Grpc.Testing.Scenario Scenario { 5848 get { return scenario_; } 5849 set { 5850 scenario_ = value; 5851 } 5852 } 5853 5854 /// <summary>Field number for the "latencies" field.</summary> 5855 public const int LatenciesFieldNumber = 2; 5856 private global::Grpc.Testing.HistogramData latencies_; 5857 /// <summary> 5858 /// Histograms from all clients merged into one histogram. 5859 /// </summary> 5860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5861 public global::Grpc.Testing.HistogramData Latencies { 5862 get { return latencies_; } 5863 set { 5864 latencies_ = value; 5865 } 5866 } 5867 5868 /// <summary>Field number for the "client_stats" field.</summary> 5869 public const int ClientStatsFieldNumber = 3; 5870 private static readonly pb::FieldCodec<global::Grpc.Testing.ClientStats> _repeated_clientStats_codec 5871 = pb::FieldCodec.ForMessage(26, global::Grpc.Testing.ClientStats.Parser); 5872 private readonly pbc::RepeatedField<global::Grpc.Testing.ClientStats> clientStats_ = new pbc::RepeatedField<global::Grpc.Testing.ClientStats>(); 5873 /// <summary> 5874 /// Client stats for each client 5875 /// </summary> 5876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5877 public pbc::RepeatedField<global::Grpc.Testing.ClientStats> ClientStats { 5878 get { return clientStats_; } 5879 } 5880 5881 /// <summary>Field number for the "server_stats" field.</summary> 5882 public const int ServerStatsFieldNumber = 4; 5883 private static readonly pb::FieldCodec<global::Grpc.Testing.ServerStats> _repeated_serverStats_codec 5884 = pb::FieldCodec.ForMessage(34, global::Grpc.Testing.ServerStats.Parser); 5885 private readonly pbc::RepeatedField<global::Grpc.Testing.ServerStats> serverStats_ = new pbc::RepeatedField<global::Grpc.Testing.ServerStats>(); 5886 /// <summary> 5887 /// Server stats for each server 5888 /// </summary> 5889 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5890 public pbc::RepeatedField<global::Grpc.Testing.ServerStats> ServerStats { 5891 get { return serverStats_; } 5892 } 5893 5894 /// <summary>Field number for the "server_cores" field.</summary> 5895 public const int ServerCoresFieldNumber = 5; 5896 private static readonly pb::FieldCodec<int> _repeated_serverCores_codec 5897 = pb::FieldCodec.ForInt32(42); 5898 private readonly pbc::RepeatedField<int> serverCores_ = new pbc::RepeatedField<int>(); 5899 /// <summary> 5900 /// Number of cores available to each server 5901 /// </summary> 5902 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5903 public pbc::RepeatedField<int> ServerCores { 5904 get { return serverCores_; } 5905 } 5906 5907 /// <summary>Field number for the "summary" field.</summary> 5908 public const int SummaryFieldNumber = 6; 5909 private global::Grpc.Testing.ScenarioResultSummary summary_; 5910 /// <summary> 5911 /// An after-the-fact computed summary 5912 /// </summary> 5913 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5914 public global::Grpc.Testing.ScenarioResultSummary Summary { 5915 get { return summary_; } 5916 set { 5917 summary_ = value; 5918 } 5919 } 5920 5921 /// <summary>Field number for the "client_success" field.</summary> 5922 public const int ClientSuccessFieldNumber = 7; 5923 private static readonly pb::FieldCodec<bool> _repeated_clientSuccess_codec 5924 = pb::FieldCodec.ForBool(58); 5925 private readonly pbc::RepeatedField<bool> clientSuccess_ = new pbc::RepeatedField<bool>(); 5926 /// <summary> 5927 /// Information on success or failure of each worker 5928 /// </summary> 5929 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5930 public pbc::RepeatedField<bool> ClientSuccess { 5931 get { return clientSuccess_; } 5932 } 5933 5934 /// <summary>Field number for the "server_success" field.</summary> 5935 public const int ServerSuccessFieldNumber = 8; 5936 private static readonly pb::FieldCodec<bool> _repeated_serverSuccess_codec 5937 = pb::FieldCodec.ForBool(66); 5938 private readonly pbc::RepeatedField<bool> serverSuccess_ = new pbc::RepeatedField<bool>(); 5939 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5940 public pbc::RepeatedField<bool> ServerSuccess { 5941 get { return serverSuccess_; } 5942 } 5943 5944 /// <summary>Field number for the "request_results" field.</summary> 5945 public const int RequestResultsFieldNumber = 9; 5946 private static readonly pb::FieldCodec<global::Grpc.Testing.RequestResultCount> _repeated_requestResults_codec 5947 = pb::FieldCodec.ForMessage(74, global::Grpc.Testing.RequestResultCount.Parser); 5948 private readonly pbc::RepeatedField<global::Grpc.Testing.RequestResultCount> requestResults_ = new pbc::RepeatedField<global::Grpc.Testing.RequestResultCount>(); 5949 /// <summary> 5950 /// Number of failed requests (one row per status code seen) 5951 /// </summary> 5952 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 5953 public pbc::RepeatedField<global::Grpc.Testing.RequestResultCount> RequestResults { 5954 get { return requestResults_; } 5955 } 5956 5957 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)5958 public override bool Equals(object other) { 5959 return Equals(other as ScenarioResult); 5960 } 5961 5962 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ScenarioResult other)5963 public bool Equals(ScenarioResult other) { 5964 if (ReferenceEquals(other, null)) { 5965 return false; 5966 } 5967 if (ReferenceEquals(other, this)) { 5968 return true; 5969 } 5970 if (!object.Equals(Scenario, other.Scenario)) return false; 5971 if (!object.Equals(Latencies, other.Latencies)) return false; 5972 if(!clientStats_.Equals(other.clientStats_)) return false; 5973 if(!serverStats_.Equals(other.serverStats_)) return false; 5974 if(!serverCores_.Equals(other.serverCores_)) return false; 5975 if (!object.Equals(Summary, other.Summary)) return false; 5976 if(!clientSuccess_.Equals(other.clientSuccess_)) return false; 5977 if(!serverSuccess_.Equals(other.serverSuccess_)) return false; 5978 if(!requestResults_.Equals(other.requestResults_)) return false; 5979 return Equals(_unknownFields, other._unknownFields); 5980 } 5981 5982 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()5983 public override int GetHashCode() { 5984 int hash = 1; 5985 if (scenario_ != null) hash ^= Scenario.GetHashCode(); 5986 if (latencies_ != null) hash ^= Latencies.GetHashCode(); 5987 hash ^= clientStats_.GetHashCode(); 5988 hash ^= serverStats_.GetHashCode(); 5989 hash ^= serverCores_.GetHashCode(); 5990 if (summary_ != null) hash ^= Summary.GetHashCode(); 5991 hash ^= clientSuccess_.GetHashCode(); 5992 hash ^= serverSuccess_.GetHashCode(); 5993 hash ^= requestResults_.GetHashCode(); 5994 if (_unknownFields != null) { 5995 hash ^= _unknownFields.GetHashCode(); 5996 } 5997 return hash; 5998 } 5999 6000 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()6001 public override string ToString() { 6002 return pb::JsonFormatter.ToDiagnosticString(this); 6003 } 6004 6005 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)6006 public void WriteTo(pb::CodedOutputStream output) { 6007 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 6008 output.WriteRawMessage(this); 6009 #else 6010 if (scenario_ != null) { 6011 output.WriteRawTag(10); 6012 output.WriteMessage(Scenario); 6013 } 6014 if (latencies_ != null) { 6015 output.WriteRawTag(18); 6016 output.WriteMessage(Latencies); 6017 } 6018 clientStats_.WriteTo(output, _repeated_clientStats_codec); 6019 serverStats_.WriteTo(output, _repeated_serverStats_codec); 6020 serverCores_.WriteTo(output, _repeated_serverCores_codec); 6021 if (summary_ != null) { 6022 output.WriteRawTag(50); 6023 output.WriteMessage(Summary); 6024 } 6025 clientSuccess_.WriteTo(output, _repeated_clientSuccess_codec); 6026 serverSuccess_.WriteTo(output, _repeated_serverSuccess_codec); 6027 requestResults_.WriteTo(output, _repeated_requestResults_codec); 6028 if (_unknownFields != null) { 6029 _unknownFields.WriteTo(output); 6030 } 6031 #endif 6032 } 6033 6034 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 6035 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalWriteTo(ref pb::WriteContext output)6036 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { 6037 if (scenario_ != null) { 6038 output.WriteRawTag(10); 6039 output.WriteMessage(Scenario); 6040 } 6041 if (latencies_ != null) { 6042 output.WriteRawTag(18); 6043 output.WriteMessage(Latencies); 6044 } 6045 clientStats_.WriteTo(ref output, _repeated_clientStats_codec); 6046 serverStats_.WriteTo(ref output, _repeated_serverStats_codec); 6047 serverCores_.WriteTo(ref output, _repeated_serverCores_codec); 6048 if (summary_ != null) { 6049 output.WriteRawTag(50); 6050 output.WriteMessage(Summary); 6051 } 6052 clientSuccess_.WriteTo(ref output, _repeated_clientSuccess_codec); 6053 serverSuccess_.WriteTo(ref output, _repeated_serverSuccess_codec); 6054 requestResults_.WriteTo(ref output, _repeated_requestResults_codec); 6055 if (_unknownFields != null) { 6056 _unknownFields.WriteTo(ref output); 6057 } 6058 } 6059 #endif 6060 6061 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()6062 public int CalculateSize() { 6063 int size = 0; 6064 if (scenario_ != null) { 6065 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Scenario); 6066 } 6067 if (latencies_ != null) { 6068 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Latencies); 6069 } 6070 size += clientStats_.CalculateSize(_repeated_clientStats_codec); 6071 size += serverStats_.CalculateSize(_repeated_serverStats_codec); 6072 size += serverCores_.CalculateSize(_repeated_serverCores_codec); 6073 if (summary_ != null) { 6074 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Summary); 6075 } 6076 size += clientSuccess_.CalculateSize(_repeated_clientSuccess_codec); 6077 size += serverSuccess_.CalculateSize(_repeated_serverSuccess_codec); 6078 size += requestResults_.CalculateSize(_repeated_requestResults_codec); 6079 if (_unknownFields != null) { 6080 size += _unknownFields.CalculateSize(); 6081 } 6082 return size; 6083 } 6084 6085 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ScenarioResult other)6086 public void MergeFrom(ScenarioResult other) { 6087 if (other == null) { 6088 return; 6089 } 6090 if (other.scenario_ != null) { 6091 if (scenario_ == null) { 6092 Scenario = new global::Grpc.Testing.Scenario(); 6093 } 6094 Scenario.MergeFrom(other.Scenario); 6095 } 6096 if (other.latencies_ != null) { 6097 if (latencies_ == null) { 6098 Latencies = new global::Grpc.Testing.HistogramData(); 6099 } 6100 Latencies.MergeFrom(other.Latencies); 6101 } 6102 clientStats_.Add(other.clientStats_); 6103 serverStats_.Add(other.serverStats_); 6104 serverCores_.Add(other.serverCores_); 6105 if (other.summary_ != null) { 6106 if (summary_ == null) { 6107 Summary = new global::Grpc.Testing.ScenarioResultSummary(); 6108 } 6109 Summary.MergeFrom(other.Summary); 6110 } 6111 clientSuccess_.Add(other.clientSuccess_); 6112 serverSuccess_.Add(other.serverSuccess_); 6113 requestResults_.Add(other.requestResults_); 6114 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 6115 } 6116 6117 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)6118 public void MergeFrom(pb::CodedInputStream input) { 6119 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 6120 input.ReadRawMessage(this); 6121 #else 6122 uint tag; 6123 while ((tag = input.ReadTag()) != 0) { 6124 switch(tag) { 6125 default: 6126 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 6127 break; 6128 case 10: { 6129 if (scenario_ == null) { 6130 Scenario = new global::Grpc.Testing.Scenario(); 6131 } 6132 input.ReadMessage(Scenario); 6133 break; 6134 } 6135 case 18: { 6136 if (latencies_ == null) { 6137 Latencies = new global::Grpc.Testing.HistogramData(); 6138 } 6139 input.ReadMessage(Latencies); 6140 break; 6141 } 6142 case 26: { 6143 clientStats_.AddEntriesFrom(input, _repeated_clientStats_codec); 6144 break; 6145 } 6146 case 34: { 6147 serverStats_.AddEntriesFrom(input, _repeated_serverStats_codec); 6148 break; 6149 } 6150 case 42: 6151 case 40: { 6152 serverCores_.AddEntriesFrom(input, _repeated_serverCores_codec); 6153 break; 6154 } 6155 case 50: { 6156 if (summary_ == null) { 6157 Summary = new global::Grpc.Testing.ScenarioResultSummary(); 6158 } 6159 input.ReadMessage(Summary); 6160 break; 6161 } 6162 case 58: 6163 case 56: { 6164 clientSuccess_.AddEntriesFrom(input, _repeated_clientSuccess_codec); 6165 break; 6166 } 6167 case 66: 6168 case 64: { 6169 serverSuccess_.AddEntriesFrom(input, _repeated_serverSuccess_codec); 6170 break; 6171 } 6172 case 74: { 6173 requestResults_.AddEntriesFrom(input, _repeated_requestResults_codec); 6174 break; 6175 } 6176 } 6177 } 6178 #endif 6179 } 6180 6181 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE 6182 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] IBufferMessage.InternalMergeFrom(ref pb::ParseContext input)6183 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { 6184 uint tag; 6185 while ((tag = input.ReadTag()) != 0) { 6186 switch(tag) { 6187 default: 6188 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); 6189 break; 6190 case 10: { 6191 if (scenario_ == null) { 6192 Scenario = new global::Grpc.Testing.Scenario(); 6193 } 6194 input.ReadMessage(Scenario); 6195 break; 6196 } 6197 case 18: { 6198 if (latencies_ == null) { 6199 Latencies = new global::Grpc.Testing.HistogramData(); 6200 } 6201 input.ReadMessage(Latencies); 6202 break; 6203 } 6204 case 26: { 6205 clientStats_.AddEntriesFrom(ref input, _repeated_clientStats_codec); 6206 break; 6207 } 6208 case 34: { 6209 serverStats_.AddEntriesFrom(ref input, _repeated_serverStats_codec); 6210 break; 6211 } 6212 case 42: 6213 case 40: { 6214 serverCores_.AddEntriesFrom(ref input, _repeated_serverCores_codec); 6215 break; 6216 } 6217 case 50: { 6218 if (summary_ == null) { 6219 Summary = new global::Grpc.Testing.ScenarioResultSummary(); 6220 } 6221 input.ReadMessage(Summary); 6222 break; 6223 } 6224 case 58: 6225 case 56: { 6226 clientSuccess_.AddEntriesFrom(ref input, _repeated_clientSuccess_codec); 6227 break; 6228 } 6229 case 66: 6230 case 64: { 6231 serverSuccess_.AddEntriesFrom(ref input, _repeated_serverSuccess_codec); 6232 break; 6233 } 6234 case 74: { 6235 requestResults_.AddEntriesFrom(ref input, _repeated_requestResults_codec); 6236 break; 6237 } 6238 } 6239 } 6240 } 6241 #endif 6242 6243 } 6244 6245 #endregion 6246 6247 } 6248 6249 #endregion Designer generated code 6250