hondacrx
1066 lines
39 KiB
C#
1066 lines
39 KiB
C#
// <auto-generated>
|
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: bgs/low/pb/client/rpc_config.proto
|
|
// </auto-generated>
|
|
#pragma warning disable 1591, 0612, 3021, 8981
|
|
#region Designer generated code
|
|
|
|
using pb = global::Google.Protobuf;
|
|
using pbc = global::Google.Protobuf.Collections;
|
|
using pbr = global::Google.Protobuf.Reflection;
|
|
using scg = global::System.Collections.Generic;
|
|
namespace Bgs.Protocol.Config {
|
|
|
|
/// <summary>Holder for reflection information generated from bgs/low/pb/client/rpc_config.proto</summary>
|
|
public static partial class RpcConfigReflection {
|
|
|
|
#region Descriptor
|
|
/// <summary>File descriptor for bgs/low/pb/client/rpc_config.proto</summary>
|
|
public static pbr::FileDescriptor Descriptor {
|
|
get { return descriptor; }
|
|
}
|
|
private static pbr::FileDescriptor descriptor;
|
|
|
|
static RpcConfigReflection() {
|
|
byte[] descriptorData = global::System.Convert.FromBase64String(
|
|
string.Concat(
|
|
"CiJiZ3MvbG93L3BiL2NsaWVudC9ycGNfY29uZmlnLnByb3RvEhNiZ3MucHJv",
|
|
"dG9jb2wuY29uZmlnIoIDCg9SUENNZXRob2RDb25maWcSGAoMc2VydmljZV9u",
|
|
"YW1lGAEgASgJQgIYARIXCgttZXRob2RfbmFtZRgCIAEoCUICGAESGgoPZml4",
|
|
"ZWRfY2FsbF9jb3N0GAMgASgNOgExEhkKEWZpeGVkX3BhY2tldF9zaXplGAQg",
|
|
"ASgNEhsKE3ZhcmlhYmxlX211bHRpcGxpZXIYBSABKAISFQoKbXVsdGlwbGll",
|
|
"chgGIAEoAjoBMRIYChByYXRlX2xpbWl0X2NvdW50GAcgASgNEhoKEnJhdGVf",
|
|
"bGltaXRfc2Vjb25kcxgIIAEoDRIXCg9tYXhfcGFja2V0X3NpemUYCSABKA0S",
|
|
"GAoQbWF4X2VuY29kZWRfc2l6ZRgKIAEoDRIPCgd0aW1lb3V0GAsgASgCEhMK",
|
|
"C2NhcF9iYWxhbmNlGAwgASgNEhkKEWluY29tZV9wZXJfc2Vjb25kGA0gASgC",
|
|
"EhQKDHNlcnZpY2VfaGFzaBgOIAEoDRIRCgltZXRob2RfaWQYDyABKA0iqgEK",
|
|
"DlJQQ01ldGVyQ29uZmlnEjQKBm1ldGhvZBgBIAMoCzIkLmJncy5wcm90b2Nv",
|
|
"bC5jb25maWcuUlBDTWV0aG9kQ29uZmlnEhwKEWluY29tZV9wZXJfc2Vjb25k",
|
|
"GAIgASgNOgExEhcKD2luaXRpYWxfYmFsYW5jZRgDIAEoDRITCgtjYXBfYmFs",
|
|
"YW5jZRgEIAEoDRIWCg5zdGFydHVwX3BlcmlvZBgFIAEoAg=="));
|
|
descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
|
|
new pbr::FileDescriptor[] { },
|
|
new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.Config.RPCMethodConfig), global::Bgs.Protocol.Config.RPCMethodConfig.Parser, new[]{ "ServiceName", "MethodName", "FixedCallCost", "FixedPacketSize", "VariableMultiplier", "Multiplier", "RateLimitCount", "RateLimitSeconds", "MaxPacketSize", "MaxEncodedSize", "Timeout", "CapBalance", "IncomePerSecond", "ServiceHash", "MethodId" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.Config.RPCMeterConfig), global::Bgs.Protocol.Config.RPCMeterConfig.Parser, new[]{ "Method", "IncomePerSecond", "InitialBalance", "CapBalance", "StartupPeriod" }, null, null, null, null)
|
|
}));
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
#region Messages
|
|
public sealed partial class RPCMethodConfig : pb::IMessage<RPCMethodConfig> {
|
|
private static readonly pb::MessageParser<RPCMethodConfig> _parser = new pb::MessageParser<RPCMethodConfig>(() => new RPCMethodConfig());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<RPCMethodConfig> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.Config.RpcConfigReflection.Descriptor.MessageTypes[0]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public RPCMethodConfig() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public RPCMethodConfig(RPCMethodConfig other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
serviceName_ = other.serviceName_;
|
|
methodName_ = other.methodName_;
|
|
fixedCallCost_ = other.fixedCallCost_;
|
|
fixedPacketSize_ = other.fixedPacketSize_;
|
|
variableMultiplier_ = other.variableMultiplier_;
|
|
multiplier_ = other.multiplier_;
|
|
rateLimitCount_ = other.rateLimitCount_;
|
|
rateLimitSeconds_ = other.rateLimitSeconds_;
|
|
maxPacketSize_ = other.maxPacketSize_;
|
|
maxEncodedSize_ = other.maxEncodedSize_;
|
|
timeout_ = other.timeout_;
|
|
capBalance_ = other.capBalance_;
|
|
incomePerSecond_ = other.incomePerSecond_;
|
|
serviceHash_ = other.serviceHash_;
|
|
methodId_ = other.methodId_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public RPCMethodConfig Clone() {
|
|
return new RPCMethodConfig(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "service_name" field.</summary>
|
|
public const int ServiceNameFieldNumber = 1;
|
|
private readonly static string ServiceNameDefaultValue = "";
|
|
|
|
private string serviceName_;
|
|
[global::System.ObsoleteAttribute]
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public string ServiceName {
|
|
get { return serviceName_ ?? ServiceNameDefaultValue; }
|
|
set {
|
|
serviceName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "service_name" field is set</summary>
|
|
[global::System.ObsoleteAttribute]
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasServiceName {
|
|
get { return serviceName_ != null; }
|
|
}
|
|
/// <summary>Clears the value of the "service_name" field</summary>
|
|
[global::System.ObsoleteAttribute]
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearServiceName() {
|
|
serviceName_ = null;
|
|
}
|
|
|
|
/// <summary>Field number for the "method_name" field.</summary>
|
|
public const int MethodNameFieldNumber = 2;
|
|
private readonly static string MethodNameDefaultValue = "";
|
|
|
|
private string methodName_;
|
|
[global::System.ObsoleteAttribute]
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public string MethodName {
|
|
get { return methodName_ ?? MethodNameDefaultValue; }
|
|
set {
|
|
methodName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "method_name" field is set</summary>
|
|
[global::System.ObsoleteAttribute]
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasMethodName {
|
|
get { return methodName_ != null; }
|
|
}
|
|
/// <summary>Clears the value of the "method_name" field</summary>
|
|
[global::System.ObsoleteAttribute]
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearMethodName() {
|
|
methodName_ = null;
|
|
}
|
|
|
|
/// <summary>Field number for the "fixed_call_cost" field.</summary>
|
|
public const int FixedCallCostFieldNumber = 3;
|
|
private readonly static uint FixedCallCostDefaultValue = 1;
|
|
|
|
private uint fixedCallCost_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint FixedCallCost {
|
|
get { if ((_hasBits0 & 1) != 0) { return fixedCallCost_; } else { return FixedCallCostDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
fixedCallCost_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "fixed_call_cost" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasFixedCallCost {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "fixed_call_cost" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearFixedCallCost() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "fixed_packet_size" field.</summary>
|
|
public const int FixedPacketSizeFieldNumber = 4;
|
|
private readonly static uint FixedPacketSizeDefaultValue = 0;
|
|
|
|
private uint fixedPacketSize_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint FixedPacketSize {
|
|
get { if ((_hasBits0 & 2) != 0) { return fixedPacketSize_; } else { return FixedPacketSizeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
fixedPacketSize_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "fixed_packet_size" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasFixedPacketSize {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "fixed_packet_size" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearFixedPacketSize() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "variable_multiplier" field.</summary>
|
|
public const int VariableMultiplierFieldNumber = 5;
|
|
private readonly static float VariableMultiplierDefaultValue = 0F;
|
|
|
|
private float variableMultiplier_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public float VariableMultiplier {
|
|
get { if ((_hasBits0 & 4) != 0) { return variableMultiplier_; } else { return VariableMultiplierDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
variableMultiplier_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "variable_multiplier" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasVariableMultiplier {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "variable_multiplier" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearVariableMultiplier() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "multiplier" field.</summary>
|
|
public const int MultiplierFieldNumber = 6;
|
|
private readonly static float MultiplierDefaultValue = 1F;
|
|
|
|
private float multiplier_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public float Multiplier {
|
|
get { if ((_hasBits0 & 8) != 0) { return multiplier_; } else { return MultiplierDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
multiplier_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "multiplier" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasMultiplier {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "multiplier" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearMultiplier() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
/// <summary>Field number for the "rate_limit_count" field.</summary>
|
|
public const int RateLimitCountFieldNumber = 7;
|
|
private readonly static uint RateLimitCountDefaultValue = 0;
|
|
|
|
private uint rateLimitCount_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint RateLimitCount {
|
|
get { if ((_hasBits0 & 16) != 0) { return rateLimitCount_; } else { return RateLimitCountDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 16;
|
|
rateLimitCount_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "rate_limit_count" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasRateLimitCount {
|
|
get { return (_hasBits0 & 16) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "rate_limit_count" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearRateLimitCount() {
|
|
_hasBits0 &= ~16;
|
|
}
|
|
|
|
/// <summary>Field number for the "rate_limit_seconds" field.</summary>
|
|
public const int RateLimitSecondsFieldNumber = 8;
|
|
private readonly static uint RateLimitSecondsDefaultValue = 0;
|
|
|
|
private uint rateLimitSeconds_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint RateLimitSeconds {
|
|
get { if ((_hasBits0 & 32) != 0) { return rateLimitSeconds_; } else { return RateLimitSecondsDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 32;
|
|
rateLimitSeconds_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "rate_limit_seconds" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasRateLimitSeconds {
|
|
get { return (_hasBits0 & 32) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "rate_limit_seconds" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearRateLimitSeconds() {
|
|
_hasBits0 &= ~32;
|
|
}
|
|
|
|
/// <summary>Field number for the "max_packet_size" field.</summary>
|
|
public const int MaxPacketSizeFieldNumber = 9;
|
|
private readonly static uint MaxPacketSizeDefaultValue = 0;
|
|
|
|
private uint maxPacketSize_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint MaxPacketSize {
|
|
get { if ((_hasBits0 & 64) != 0) { return maxPacketSize_; } else { return MaxPacketSizeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 64;
|
|
maxPacketSize_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "max_packet_size" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasMaxPacketSize {
|
|
get { return (_hasBits0 & 64) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "max_packet_size" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearMaxPacketSize() {
|
|
_hasBits0 &= ~64;
|
|
}
|
|
|
|
/// <summary>Field number for the "max_encoded_size" field.</summary>
|
|
public const int MaxEncodedSizeFieldNumber = 10;
|
|
private readonly static uint MaxEncodedSizeDefaultValue = 0;
|
|
|
|
private uint maxEncodedSize_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint MaxEncodedSize {
|
|
get { if ((_hasBits0 & 128) != 0) { return maxEncodedSize_; } else { return MaxEncodedSizeDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 128;
|
|
maxEncodedSize_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "max_encoded_size" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasMaxEncodedSize {
|
|
get { return (_hasBits0 & 128) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "max_encoded_size" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearMaxEncodedSize() {
|
|
_hasBits0 &= ~128;
|
|
}
|
|
|
|
/// <summary>Field number for the "timeout" field.</summary>
|
|
public const int TimeoutFieldNumber = 11;
|
|
private readonly static float TimeoutDefaultValue = 0F;
|
|
|
|
private float timeout_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public float Timeout {
|
|
get { if ((_hasBits0 & 256) != 0) { return timeout_; } else { return TimeoutDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 256;
|
|
timeout_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "timeout" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasTimeout {
|
|
get { return (_hasBits0 & 256) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "timeout" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearTimeout() {
|
|
_hasBits0 &= ~256;
|
|
}
|
|
|
|
/// <summary>Field number for the "cap_balance" field.</summary>
|
|
public const int CapBalanceFieldNumber = 12;
|
|
private readonly static uint CapBalanceDefaultValue = 0;
|
|
|
|
private uint capBalance_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint CapBalance {
|
|
get { if ((_hasBits0 & 512) != 0) { return capBalance_; } else { return CapBalanceDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 512;
|
|
capBalance_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "cap_balance" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasCapBalance {
|
|
get { return (_hasBits0 & 512) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "cap_balance" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearCapBalance() {
|
|
_hasBits0 &= ~512;
|
|
}
|
|
|
|
/// <summary>Field number for the "income_per_second" field.</summary>
|
|
public const int IncomePerSecondFieldNumber = 13;
|
|
private readonly static float IncomePerSecondDefaultValue = 0F;
|
|
|
|
private float incomePerSecond_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public float IncomePerSecond {
|
|
get { if ((_hasBits0 & 1024) != 0) { return incomePerSecond_; } else { return IncomePerSecondDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1024;
|
|
incomePerSecond_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "income_per_second" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasIncomePerSecond {
|
|
get { return (_hasBits0 & 1024) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "income_per_second" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearIncomePerSecond() {
|
|
_hasBits0 &= ~1024;
|
|
}
|
|
|
|
/// <summary>Field number for the "service_hash" field.</summary>
|
|
public const int ServiceHashFieldNumber = 14;
|
|
private readonly static uint ServiceHashDefaultValue = 0;
|
|
|
|
private uint serviceHash_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint ServiceHash {
|
|
get { if ((_hasBits0 & 2048) != 0) { return serviceHash_; } else { return ServiceHashDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2048;
|
|
serviceHash_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "service_hash" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasServiceHash {
|
|
get { return (_hasBits0 & 2048) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "service_hash" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearServiceHash() {
|
|
_hasBits0 &= ~2048;
|
|
}
|
|
|
|
/// <summary>Field number for the "method_id" field.</summary>
|
|
public const int MethodIdFieldNumber = 15;
|
|
private readonly static uint MethodIdDefaultValue = 0;
|
|
|
|
private uint methodId_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint MethodId {
|
|
get { if ((_hasBits0 & 4096) != 0) { return methodId_; } else { return MethodIdDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4096;
|
|
methodId_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "method_id" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasMethodId {
|
|
get { return (_hasBits0 & 4096) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "method_id" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearMethodId() {
|
|
_hasBits0 &= ~4096;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as RPCMethodConfig);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(RPCMethodConfig other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (ServiceName != other.ServiceName) return false;
|
|
if (MethodName != other.MethodName) return false;
|
|
if (FixedCallCost != other.FixedCallCost) return false;
|
|
if (FixedPacketSize != other.FixedPacketSize) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(VariableMultiplier, other.VariableMultiplier)) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Multiplier, other.Multiplier)) return false;
|
|
if (RateLimitCount != other.RateLimitCount) return false;
|
|
if (RateLimitSeconds != other.RateLimitSeconds) return false;
|
|
if (MaxPacketSize != other.MaxPacketSize) return false;
|
|
if (MaxEncodedSize != other.MaxEncodedSize) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Timeout, other.Timeout)) return false;
|
|
if (CapBalance != other.CapBalance) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(IncomePerSecond, other.IncomePerSecond)) return false;
|
|
if (ServiceHash != other.ServiceHash) return false;
|
|
if (MethodId != other.MethodId) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasServiceName) hash ^= ServiceName.GetHashCode();
|
|
if (HasMethodName) hash ^= MethodName.GetHashCode();
|
|
if (HasFixedCallCost) hash ^= FixedCallCost.GetHashCode();
|
|
if (HasFixedPacketSize) hash ^= FixedPacketSize.GetHashCode();
|
|
if (HasVariableMultiplier) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(VariableMultiplier);
|
|
if (HasMultiplier) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Multiplier);
|
|
if (HasRateLimitCount) hash ^= RateLimitCount.GetHashCode();
|
|
if (HasRateLimitSeconds) hash ^= RateLimitSeconds.GetHashCode();
|
|
if (HasMaxPacketSize) hash ^= MaxPacketSize.GetHashCode();
|
|
if (HasMaxEncodedSize) hash ^= MaxEncodedSize.GetHashCode();
|
|
if (HasTimeout) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Timeout);
|
|
if (HasCapBalance) hash ^= CapBalance.GetHashCode();
|
|
if (HasIncomePerSecond) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(IncomePerSecond);
|
|
if (HasServiceHash) hash ^= ServiceHash.GetHashCode();
|
|
if (HasMethodId) hash ^= MethodId.GetHashCode();
|
|
if (_unknownFields != null) {
|
|
hash ^= _unknownFields.GetHashCode();
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override string ToString() {
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void WriteTo(pb::CodedOutputStream output) {
|
|
if (HasServiceName) {
|
|
output.WriteRawTag(10);
|
|
output.WriteString(ServiceName);
|
|
}
|
|
if (HasMethodName) {
|
|
output.WriteRawTag(18);
|
|
output.WriteString(MethodName);
|
|
}
|
|
if (HasFixedCallCost) {
|
|
output.WriteRawTag(24);
|
|
output.WriteUInt32(FixedCallCost);
|
|
}
|
|
if (HasFixedPacketSize) {
|
|
output.WriteRawTag(32);
|
|
output.WriteUInt32(FixedPacketSize);
|
|
}
|
|
if (HasVariableMultiplier) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(VariableMultiplier);
|
|
}
|
|
if (HasMultiplier) {
|
|
output.WriteRawTag(53);
|
|
output.WriteFloat(Multiplier);
|
|
}
|
|
if (HasRateLimitCount) {
|
|
output.WriteRawTag(56);
|
|
output.WriteUInt32(RateLimitCount);
|
|
}
|
|
if (HasRateLimitSeconds) {
|
|
output.WriteRawTag(64);
|
|
output.WriteUInt32(RateLimitSeconds);
|
|
}
|
|
if (HasMaxPacketSize) {
|
|
output.WriteRawTag(72);
|
|
output.WriteUInt32(MaxPacketSize);
|
|
}
|
|
if (HasMaxEncodedSize) {
|
|
output.WriteRawTag(80);
|
|
output.WriteUInt32(MaxEncodedSize);
|
|
}
|
|
if (HasTimeout) {
|
|
output.WriteRawTag(93);
|
|
output.WriteFloat(Timeout);
|
|
}
|
|
if (HasCapBalance) {
|
|
output.WriteRawTag(96);
|
|
output.WriteUInt32(CapBalance);
|
|
}
|
|
if (HasIncomePerSecond) {
|
|
output.WriteRawTag(109);
|
|
output.WriteFloat(IncomePerSecond);
|
|
}
|
|
if (HasServiceHash) {
|
|
output.WriteRawTag(112);
|
|
output.WriteUInt32(ServiceHash);
|
|
}
|
|
if (HasMethodId) {
|
|
output.WriteRawTag(120);
|
|
output.WriteUInt32(MethodId);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasServiceName) {
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(ServiceName);
|
|
}
|
|
if (HasMethodName) {
|
|
size += 1 + pb::CodedOutputStream.ComputeStringSize(MethodName);
|
|
}
|
|
if (HasFixedCallCost) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(FixedCallCost);
|
|
}
|
|
if (HasFixedPacketSize) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(FixedPacketSize);
|
|
}
|
|
if (HasVariableMultiplier) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasMultiplier) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasRateLimitCount) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(RateLimitCount);
|
|
}
|
|
if (HasRateLimitSeconds) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(RateLimitSeconds);
|
|
}
|
|
if (HasMaxPacketSize) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MaxPacketSize);
|
|
}
|
|
if (HasMaxEncodedSize) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MaxEncodedSize);
|
|
}
|
|
if (HasTimeout) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasCapBalance) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(CapBalance);
|
|
}
|
|
if (HasIncomePerSecond) {
|
|
size += 1 + 4;
|
|
}
|
|
if (HasServiceHash) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(ServiceHash);
|
|
}
|
|
if (HasMethodId) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(MethodId);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(RPCMethodConfig other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasServiceName) {
|
|
ServiceName = other.ServiceName;
|
|
}
|
|
if (other.HasMethodName) {
|
|
MethodName = other.MethodName;
|
|
}
|
|
if (other.HasFixedCallCost) {
|
|
FixedCallCost = other.FixedCallCost;
|
|
}
|
|
if (other.HasFixedPacketSize) {
|
|
FixedPacketSize = other.FixedPacketSize;
|
|
}
|
|
if (other.HasVariableMultiplier) {
|
|
VariableMultiplier = other.VariableMultiplier;
|
|
}
|
|
if (other.HasMultiplier) {
|
|
Multiplier = other.Multiplier;
|
|
}
|
|
if (other.HasRateLimitCount) {
|
|
RateLimitCount = other.RateLimitCount;
|
|
}
|
|
if (other.HasRateLimitSeconds) {
|
|
RateLimitSeconds = other.RateLimitSeconds;
|
|
}
|
|
if (other.HasMaxPacketSize) {
|
|
MaxPacketSize = other.MaxPacketSize;
|
|
}
|
|
if (other.HasMaxEncodedSize) {
|
|
MaxEncodedSize = other.MaxEncodedSize;
|
|
}
|
|
if (other.HasTimeout) {
|
|
Timeout = other.Timeout;
|
|
}
|
|
if (other.HasCapBalance) {
|
|
CapBalance = other.CapBalance;
|
|
}
|
|
if (other.HasIncomePerSecond) {
|
|
IncomePerSecond = other.IncomePerSecond;
|
|
}
|
|
if (other.HasServiceHash) {
|
|
ServiceHash = other.ServiceHash;
|
|
}
|
|
if (other.HasMethodId) {
|
|
MethodId = other.MethodId;
|
|
}
|
|
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(pb::CodedInputStream input) {
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0) {
|
|
switch(tag) {
|
|
default:
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
|
|
break;
|
|
case 10: {
|
|
ServiceName = input.ReadString();
|
|
break;
|
|
}
|
|
case 18: {
|
|
MethodName = input.ReadString();
|
|
break;
|
|
}
|
|
case 24: {
|
|
FixedCallCost = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
FixedPacketSize = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 45: {
|
|
VariableMultiplier = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 53: {
|
|
Multiplier = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 56: {
|
|
RateLimitCount = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 64: {
|
|
RateLimitSeconds = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 72: {
|
|
MaxPacketSize = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 80: {
|
|
MaxEncodedSize = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 93: {
|
|
Timeout = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 96: {
|
|
CapBalance = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 109: {
|
|
IncomePerSecond = input.ReadFloat();
|
|
break;
|
|
}
|
|
case 112: {
|
|
ServiceHash = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 120: {
|
|
MethodId = input.ReadUInt32();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public sealed partial class RPCMeterConfig : pb::IMessage<RPCMeterConfig> {
|
|
private static readonly pb::MessageParser<RPCMeterConfig> _parser = new pb::MessageParser<RPCMeterConfig>(() => new RPCMeterConfig());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<RPCMeterConfig> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.Config.RpcConfigReflection.Descriptor.MessageTypes[1]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public RPCMeterConfig() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public RPCMeterConfig(RPCMeterConfig other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
method_ = other.method_.Clone();
|
|
incomePerSecond_ = other.incomePerSecond_;
|
|
initialBalance_ = other.initialBalance_;
|
|
capBalance_ = other.capBalance_;
|
|
startupPeriod_ = other.startupPeriod_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public RPCMeterConfig Clone() {
|
|
return new RPCMeterConfig(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "method" field.</summary>
|
|
public const int MethodFieldNumber = 1;
|
|
private static readonly pb::FieldCodec<global::Bgs.Protocol.Config.RPCMethodConfig> _repeated_method_codec
|
|
= pb::FieldCodec.ForMessage(10, global::Bgs.Protocol.Config.RPCMethodConfig.Parser);
|
|
private readonly pbc::RepeatedField<global::Bgs.Protocol.Config.RPCMethodConfig> method_ = new pbc::RepeatedField<global::Bgs.Protocol.Config.RPCMethodConfig>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public pbc::RepeatedField<global::Bgs.Protocol.Config.RPCMethodConfig> Method {
|
|
get { return method_; }
|
|
}
|
|
|
|
/// <summary>Field number for the "income_per_second" field.</summary>
|
|
public const int IncomePerSecondFieldNumber = 2;
|
|
private readonly static uint IncomePerSecondDefaultValue = 1;
|
|
|
|
private uint incomePerSecond_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint IncomePerSecond {
|
|
get { if ((_hasBits0 & 1) != 0) { return incomePerSecond_; } else { return IncomePerSecondDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
incomePerSecond_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "income_per_second" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasIncomePerSecond {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "income_per_second" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearIncomePerSecond() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "initial_balance" field.</summary>
|
|
public const int InitialBalanceFieldNumber = 3;
|
|
private readonly static uint InitialBalanceDefaultValue = 0;
|
|
|
|
private uint initialBalance_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint InitialBalance {
|
|
get { if ((_hasBits0 & 2) != 0) { return initialBalance_; } else { return InitialBalanceDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
initialBalance_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "initial_balance" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasInitialBalance {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "initial_balance" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearInitialBalance() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "cap_balance" field.</summary>
|
|
public const int CapBalanceFieldNumber = 4;
|
|
private readonly static uint CapBalanceDefaultValue = 0;
|
|
|
|
private uint capBalance_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public uint CapBalance {
|
|
get { if ((_hasBits0 & 4) != 0) { return capBalance_; } else { return CapBalanceDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
capBalance_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "cap_balance" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasCapBalance {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "cap_balance" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearCapBalance() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
/// <summary>Field number for the "startup_period" field.</summary>
|
|
public const int StartupPeriodFieldNumber = 5;
|
|
private readonly static float StartupPeriodDefaultValue = 0F;
|
|
|
|
private float startupPeriod_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public float StartupPeriod {
|
|
get { if ((_hasBits0 & 8) != 0) { return startupPeriod_; } else { return StartupPeriodDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 8;
|
|
startupPeriod_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "startup_period" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasStartupPeriod {
|
|
get { return (_hasBits0 & 8) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "startup_period" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearStartupPeriod() {
|
|
_hasBits0 &= ~8;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as RPCMeterConfig);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(RPCMeterConfig other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if(!method_.Equals(other.method_)) return false;
|
|
if (IncomePerSecond != other.IncomePerSecond) return false;
|
|
if (InitialBalance != other.InitialBalance) return false;
|
|
if (CapBalance != other.CapBalance) return false;
|
|
if (!pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(StartupPeriod, other.StartupPeriod)) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
hash ^= method_.GetHashCode();
|
|
if (HasIncomePerSecond) hash ^= IncomePerSecond.GetHashCode();
|
|
if (HasInitialBalance) hash ^= InitialBalance.GetHashCode();
|
|
if (HasCapBalance) hash ^= CapBalance.GetHashCode();
|
|
if (HasStartupPeriod) hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(StartupPeriod);
|
|
if (_unknownFields != null) {
|
|
hash ^= _unknownFields.GetHashCode();
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override string ToString() {
|
|
return pb::JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void WriteTo(pb::CodedOutputStream output) {
|
|
method_.WriteTo(output, _repeated_method_codec);
|
|
if (HasIncomePerSecond) {
|
|
output.WriteRawTag(16);
|
|
output.WriteUInt32(IncomePerSecond);
|
|
}
|
|
if (HasInitialBalance) {
|
|
output.WriteRawTag(24);
|
|
output.WriteUInt32(InitialBalance);
|
|
}
|
|
if (HasCapBalance) {
|
|
output.WriteRawTag(32);
|
|
output.WriteUInt32(CapBalance);
|
|
}
|
|
if (HasStartupPeriod) {
|
|
output.WriteRawTag(45);
|
|
output.WriteFloat(StartupPeriod);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
size += method_.CalculateSize(_repeated_method_codec);
|
|
if (HasIncomePerSecond) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(IncomePerSecond);
|
|
}
|
|
if (HasInitialBalance) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(InitialBalance);
|
|
}
|
|
if (HasCapBalance) {
|
|
size += 1 + pb::CodedOutputStream.ComputeUInt32Size(CapBalance);
|
|
}
|
|
if (HasStartupPeriod) {
|
|
size += 1 + 4;
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(RPCMeterConfig other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
method_.Add(other.method_);
|
|
if (other.HasIncomePerSecond) {
|
|
IncomePerSecond = other.IncomePerSecond;
|
|
}
|
|
if (other.HasInitialBalance) {
|
|
InitialBalance = other.InitialBalance;
|
|
}
|
|
if (other.HasCapBalance) {
|
|
CapBalance = other.CapBalance;
|
|
}
|
|
if (other.HasStartupPeriod) {
|
|
StartupPeriod = other.StartupPeriod;
|
|
}
|
|
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(pb::CodedInputStream input) {
|
|
uint tag;
|
|
while ((tag = input.ReadTag()) != 0) {
|
|
switch(tag) {
|
|
default:
|
|
_unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
|
|
break;
|
|
case 10: {
|
|
method_.AddEntriesFrom(input, _repeated_method_codec);
|
|
break;
|
|
}
|
|
case 16: {
|
|
IncomePerSecond = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 24: {
|
|
InitialBalance = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 32: {
|
|
CapBalance = input.ReadUInt32();
|
|
break;
|
|
}
|
|
case 45: {
|
|
StartupPeriod = input.ReadFloat();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion Designer generated code
|