hondacrx
2294 lines
81 KiB
C#
2294 lines
81 KiB
C#
// <auto-generated>
|
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: bgs/low/pb/client/global_extensions/field_options.proto
|
|
// </auto-generated>
|
|
#pragma warning disable 1591, 0612, 3021
|
|
#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 {
|
|
|
|
/// <summary>Holder for reflection information generated from bgs/low/pb/client/global_extensions/field_options.proto</summary>
|
|
public static partial class FieldOptionsReflection {
|
|
|
|
#region Descriptor
|
|
/// <summary>File descriptor for bgs/low/pb/client/global_extensions/field_options.proto</summary>
|
|
public static pbr::FileDescriptor Descriptor {
|
|
get { return descriptor; }
|
|
}
|
|
private static pbr::FileDescriptor descriptor;
|
|
|
|
static FieldOptionsReflection() {
|
|
byte[] descriptorData = global::System.Convert.FromBase64String(
|
|
string.Concat(
|
|
"CjdiZ3MvbG93L3BiL2NsaWVudC9nbG9iYWxfZXh0ZW5zaW9ucy9maWVsZF9v",
|
|
"cHRpb25zLnByb3RvEgxiZ3MucHJvdG9jb2waIGdvb2dsZS9wcm90b2J1Zi9k",
|
|
"ZXNjcmlwdG9yLnByb3RvGi9iZ3MvbG93L3BiL2NsaWVudC9nbG9iYWxfZXh0",
|
|
"ZW5zaW9ucy9yYW5nZS5wcm90byJmCg9CR1NGaWVsZE9wdGlvbnMSLAoDbG9n",
|
|
"GAEgASgOMhcuYmdzLnByb3RvY29sLkxvZ09wdGlvbjoGSElEREVOEhEKCXNo",
|
|
"YXJkX2tleRgCIAEoCBISCgpmYW5vdXRfa2V5GAMgASgIIqoDChBGaWVsZFJl",
|
|
"c3RyaWN0aW9uEjYKBnNpZ25lZBgBIAEoCzIkLmJncy5wcm90b2NvbC5TaWdu",
|
|
"ZWRGaWVsZFJlc3RyaWN0aW9uSAASOgoIdW5zaWduZWQYAiABKAsyJi5iZ3Mu",
|
|
"cHJvdG9jb2wuVW5zaWduZWRGaWVsZFJlc3RyaWN0aW9uSAASNAoFZmxvYXQY",
|
|
"AyABKAsyIy5iZ3MucHJvdG9jb2wuRmxvYXRGaWVsZFJlc3RyaWN0aW9uSAAS",
|
|
"NgoGc3RyaW5nGAQgASgLMiQuYmdzLnByb3RvY29sLlN0cmluZ0ZpZWxkUmVz",
|
|
"dHJpY3Rpb25IABI6CghyZXBlYXRlZBgFIAEoCzImLmJncy5wcm90b2NvbC5S",
|
|
"ZXBlYXRlZEZpZWxkUmVzdHJpY3Rpb25IABI4CgdtZXNzYWdlGAYgASgLMiUu",
|
|
"YmdzLnByb3RvY29sLk1lc3NhZ2VGaWVsZFJlc3RyaWN0aW9uSAASNgoJZW50",
|
|
"aXR5X2lkGAcgASgLMiEuYmdzLnByb3RvY29sLkVudGl0eUlkUmVzdHJpY3Rp",
|
|
"b25IAEIGCgR0eXBlIvoCChhSZXBlYXRlZEZpZWxkUmVzdHJpY3Rpb24SLAoE",
|
|
"c2l6ZRgBIAEoCzIeLmJncy5wcm90b2NvbC5VbnNpZ25lZEludFJhbmdlEg4K",
|
|
"BnVuaXF1ZRgCIAEoCBI2CgZzaWduZWQYAyABKAsyJC5iZ3MucHJvdG9jb2wu",
|
|
"U2lnbmVkRmllbGRSZXN0cmljdGlvbkgAEjoKCHVuc2lnbmVkGAQgASgLMiYu",
|
|
"YmdzLnByb3RvY29sLlVuc2lnbmVkRmllbGRSZXN0cmljdGlvbkgAEjQKBWZs",
|
|
"b2F0GAUgASgLMiMuYmdzLnByb3RvY29sLkZsb2F0RmllbGRSZXN0cmljdGlv",
|
|
"bkgAEjYKBnN0cmluZxgGIAEoCzIkLmJncy5wcm90b2NvbC5TdHJpbmdGaWVs",
|
|
"ZFJlc3RyaWN0aW9uSAASNgoJZW50aXR5X2lkGAcgASgLMiEuYmdzLnByb3Rv",
|
|
"Y29sLkVudGl0eUlkUmVzdHJpY3Rpb25IAEIGCgR0eXBlIlcKFlNpZ25lZEZp",
|
|
"ZWxkUmVzdHJpY3Rpb24SLAoGbGltaXRzGAEgASgLMhwuYmdzLnByb3RvY29s",
|
|
"LlNpZ25lZEludFJhbmdlEg8KB2V4Y2x1ZGUYAiADKBIiWwoYVW5zaWduZWRG",
|
|
"aWVsZFJlc3RyaWN0aW9uEi4KBmxpbWl0cxgBIAEoCzIeLmJncy5wcm90b2Nv",
|
|
"bC5VbnNpZ25lZEludFJhbmdlEg8KB2V4Y2x1ZGUYAiADKAQiUgoVRmxvYXRG",
|
|
"aWVsZFJlc3RyaWN0aW9uEigKBmxpbWl0cxgBIAEoCzIYLmJncy5wcm90b2Nv",
|
|
"bC5GbG9hdFJhbmdlEg8KB2V4Y2x1ZGUYAiADKAIiVwoWU3RyaW5nRmllbGRS",
|
|
"ZXN0cmljdGlvbhIsCgRzaXplGAEgASgLMh4uYmdzLnByb3RvY29sLlVuc2ln",
|
|
"bmVkSW50UmFuZ2USDwoHZXhjbHVkZRgCIAMoCSLHAQoTRW50aXR5SWRSZXN0",
|
|
"cmljdGlvbhIOCgZuZWVkZWQYASABKAgSOQoEa2luZBgCIAEoDjImLmJncy5w",
|
|
"cm90b2NvbC5FbnRpdHlJZFJlc3RyaWN0aW9uLktpbmQ6A0FOWSJlCgRLaW5k",
|
|
"EgcKA0FOWRAAEgsKB0FDQ09VTlQQARIQCgxHQU1FX0FDQ09VTlQQAhIbChdB",
|
|
"Q0NPVU5UX09SX0dBTUVfQUNDT1VOVBADEgsKB1NFUlZJQ0UQBBILCgdDSEFO",
|
|
"TkVMEAUiKQoXTWVzc2FnZUZpZWxkUmVzdHJpY3Rpb24SDgoGbmVlZGVkGAEg",
|
|
"ASgIKiAKCUxvZ09wdGlvbhIKCgZISURERU4QARIHCgNIRVgQAjpVCg1maWVs",
|
|
"ZF9vcHRpb25zEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxiQvwUg",
|
|
"ASgLMh0uYmdzLnByb3RvY29sLkJHU0ZpZWxkT3B0aW9uczpOCgV2YWxpZBId",
|
|
"Lmdvb2dsZS5wcm90b2J1Zi5GaWVsZE9wdGlvbnMYkb8FIAEoCzIeLmJncy5w",
|
|
"cm90b2NvbC5GaWVsZFJlc3RyaWN0aW9uQiIKDWJuZXQucHJvdG9jb2xCEUZp",
|
|
"ZWxkT3B0aW9uc1Byb3Rv"));
|
|
descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
|
|
new pbr::FileDescriptor[] { global::Google.Protobuf.DescriptorReflection.Descriptor, global::Bgs.Protocol.RangeReflection.Descriptor, },
|
|
new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Bgs.Protocol.LogOption), }, new pb::Extension[] { FieldOptionsExtensions.FieldOptions_, FieldOptionsExtensions.Valid }, new pbr::GeneratedClrTypeInfo[] {
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.BGSFieldOptions), global::Bgs.Protocol.BGSFieldOptions.Parser, new[]{ "Log", "ShardKey", "FanoutKey" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.FieldRestriction), global::Bgs.Protocol.FieldRestriction.Parser, new[]{ "Signed", "Unsigned", "Float", "String", "Repeated", "Message", "EntityId" }, new[]{ "Type" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.RepeatedFieldRestriction), global::Bgs.Protocol.RepeatedFieldRestriction.Parser, new[]{ "Size", "Unique", "Signed", "Unsigned", "Float", "String", "EntityId" }, new[]{ "Type" }, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.SignedFieldRestriction), global::Bgs.Protocol.SignedFieldRestriction.Parser, new[]{ "Limits", "Exclude" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.UnsignedFieldRestriction), global::Bgs.Protocol.UnsignedFieldRestriction.Parser, new[]{ "Limits", "Exclude" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.FloatFieldRestriction), global::Bgs.Protocol.FloatFieldRestriction.Parser, new[]{ "Limits", "Exclude" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.StringFieldRestriction), global::Bgs.Protocol.StringFieldRestriction.Parser, new[]{ "Size", "Exclude" }, null, null, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.EntityIdRestriction), global::Bgs.Protocol.EntityIdRestriction.Parser, new[]{ "Needed", "Kind" }, null, new[]{ typeof(global::Bgs.Protocol.EntityIdRestriction.Types.Kind) }, null, null),
|
|
new pbr::GeneratedClrTypeInfo(typeof(global::Bgs.Protocol.MessageFieldRestriction), global::Bgs.Protocol.MessageFieldRestriction.Parser, new[]{ "Needed" }, null, null, null, null)
|
|
}));
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
/// <summary>Holder for extension identifiers generated from the top level of bgs/low/pb/client/global_extensions/field_options.proto</summary>
|
|
public static partial class FieldOptionsExtensions {
|
|
public static readonly pb::Extension<global::Google.Protobuf.FieldOptions, global::Bgs.Protocol.BGSFieldOptions> FieldOptions_ =
|
|
new pb::Extension<global::Google.Protobuf.FieldOptions, global::Bgs.Protocol.BGSFieldOptions>(90000, pb::FieldCodec.ForMessage(720002, global::Bgs.Protocol.BGSFieldOptions.Parser));
|
|
public static readonly pb::Extension<global::Google.Protobuf.FieldOptions, global::Bgs.Protocol.FieldRestriction> Valid =
|
|
new pb::Extension<global::Google.Protobuf.FieldOptions, global::Bgs.Protocol.FieldRestriction>(90001, pb::FieldCodec.ForMessage(720010, global::Bgs.Protocol.FieldRestriction.Parser));
|
|
}
|
|
|
|
#region Enums
|
|
public enum LogOption {
|
|
[pbr::OriginalName("HIDDEN")] Hidden = 1,
|
|
[pbr::OriginalName("HEX")] Hex = 2,
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Messages
|
|
public sealed partial class BGSFieldOptions : pb::IMessage<BGSFieldOptions> {
|
|
private static readonly pb::MessageParser<BGSFieldOptions> _parser = new pb::MessageParser<BGSFieldOptions>(() => new BGSFieldOptions());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<BGSFieldOptions> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.FieldOptionsReflection.Descriptor.MessageTypes[0]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public BGSFieldOptions() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public BGSFieldOptions(BGSFieldOptions other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
log_ = other.log_;
|
|
shardKey_ = other.shardKey_;
|
|
fanoutKey_ = other.fanoutKey_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public BGSFieldOptions Clone() {
|
|
return new BGSFieldOptions(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "log" field.</summary>
|
|
public const int LogFieldNumber = 1;
|
|
private readonly static global::Bgs.Protocol.LogOption LogDefaultValue = global::Bgs.Protocol.LogOption.Hidden;
|
|
|
|
private global::Bgs.Protocol.LogOption log_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.LogOption Log {
|
|
get { if ((_hasBits0 & 1) != 0) { return log_; } else { return LogDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
log_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "log" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasLog {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "log" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearLog() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "shard_key" field.</summary>
|
|
public const int ShardKeyFieldNumber = 2;
|
|
private readonly static bool ShardKeyDefaultValue = false;
|
|
|
|
private bool shardKey_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool ShardKey {
|
|
get { if ((_hasBits0 & 2) != 0) { return shardKey_; } else { return ShardKeyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
shardKey_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "shard_key" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasShardKey {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "shard_key" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearShardKey() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
/// <summary>Field number for the "fanout_key" field.</summary>
|
|
public const int FanoutKeyFieldNumber = 3;
|
|
private readonly static bool FanoutKeyDefaultValue = false;
|
|
|
|
private bool fanoutKey_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool FanoutKey {
|
|
get { if ((_hasBits0 & 4) != 0) { return fanoutKey_; } else { return FanoutKeyDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 4;
|
|
fanoutKey_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "fanout_key" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasFanoutKey {
|
|
get { return (_hasBits0 & 4) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "fanout_key" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearFanoutKey() {
|
|
_hasBits0 &= ~4;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as BGSFieldOptions);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(BGSFieldOptions other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (Log != other.Log) return false;
|
|
if (ShardKey != other.ShardKey) return false;
|
|
if (FanoutKey != other.FanoutKey) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasLog) hash ^= Log.GetHashCode();
|
|
if (HasShardKey) hash ^= ShardKey.GetHashCode();
|
|
if (HasFanoutKey) hash ^= FanoutKey.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 (HasLog) {
|
|
output.WriteRawTag(8);
|
|
output.WriteEnum((int) Log);
|
|
}
|
|
if (HasShardKey) {
|
|
output.WriteRawTag(16);
|
|
output.WriteBool(ShardKey);
|
|
}
|
|
if (HasFanoutKey) {
|
|
output.WriteRawTag(24);
|
|
output.WriteBool(FanoutKey);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasLog) {
|
|
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Log);
|
|
}
|
|
if (HasShardKey) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasFanoutKey) {
|
|
size += 1 + 1;
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(BGSFieldOptions other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasLog) {
|
|
Log = other.Log;
|
|
}
|
|
if (other.HasShardKey) {
|
|
ShardKey = other.ShardKey;
|
|
}
|
|
if (other.HasFanoutKey) {
|
|
FanoutKey = other.FanoutKey;
|
|
}
|
|
_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 8: {
|
|
Log = (global::Bgs.Protocol.LogOption) input.ReadEnum();
|
|
break;
|
|
}
|
|
case 16: {
|
|
ShardKey = input.ReadBool();
|
|
break;
|
|
}
|
|
case 24: {
|
|
FanoutKey = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public sealed partial class FieldRestriction : pb::IMessage<FieldRestriction> {
|
|
private static readonly pb::MessageParser<FieldRestriction> _parser = new pb::MessageParser<FieldRestriction>(() => new FieldRestriction());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<FieldRestriction> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.FieldOptionsReflection.Descriptor.MessageTypes[1]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public FieldRestriction() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public FieldRestriction(FieldRestriction other) : this() {
|
|
switch (other.TypeCase) {
|
|
case TypeOneofCase.Signed:
|
|
Signed = other.Signed.Clone();
|
|
break;
|
|
case TypeOneofCase.Unsigned:
|
|
Unsigned = other.Unsigned.Clone();
|
|
break;
|
|
case TypeOneofCase.Float:
|
|
Float = other.Float.Clone();
|
|
break;
|
|
case TypeOneofCase.String:
|
|
String = other.String.Clone();
|
|
break;
|
|
case TypeOneofCase.Repeated:
|
|
Repeated = other.Repeated.Clone();
|
|
break;
|
|
case TypeOneofCase.Message:
|
|
Message = other.Message.Clone();
|
|
break;
|
|
case TypeOneofCase.EntityId:
|
|
EntityId = other.EntityId.Clone();
|
|
break;
|
|
}
|
|
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public FieldRestriction Clone() {
|
|
return new FieldRestriction(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "signed" field.</summary>
|
|
public const int SignedFieldNumber = 1;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.SignedFieldRestriction Signed {
|
|
get { return HasSigned ? (global::Bgs.Protocol.SignedFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.Signed;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "signed" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasSigned {
|
|
get { return typeCase_ == TypeOneofCase.Signed; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "signed" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearSigned() {
|
|
if (HasSigned) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "unsigned" field.</summary>
|
|
public const int UnsignedFieldNumber = 2;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.UnsignedFieldRestriction Unsigned {
|
|
get { return HasUnsigned ? (global::Bgs.Protocol.UnsignedFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.Unsigned;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "unsigned" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasUnsigned {
|
|
get { return typeCase_ == TypeOneofCase.Unsigned; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "unsigned" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearUnsigned() {
|
|
if (HasUnsigned) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "float" field.</summary>
|
|
public const int FloatFieldNumber = 3;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.FloatFieldRestriction Float {
|
|
get { return HasFloat ? (global::Bgs.Protocol.FloatFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.Float;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "float" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasFloat {
|
|
get { return typeCase_ == TypeOneofCase.Float; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "float" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearFloat() {
|
|
if (HasFloat) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "string" field.</summary>
|
|
public const int StringFieldNumber = 4;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.StringFieldRestriction String {
|
|
get { return HasString ? (global::Bgs.Protocol.StringFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.String;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "string" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasString {
|
|
get { return typeCase_ == TypeOneofCase.String; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "string" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearString() {
|
|
if (HasString) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "repeated" field.</summary>
|
|
public const int RepeatedFieldNumber = 5;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.RepeatedFieldRestriction Repeated {
|
|
get { return HasRepeated ? (global::Bgs.Protocol.RepeatedFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.Repeated;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "repeated" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasRepeated {
|
|
get { return typeCase_ == TypeOneofCase.Repeated; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "repeated" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearRepeated() {
|
|
if (HasRepeated) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "message" field.</summary>
|
|
public const int MessageFieldNumber = 6;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.MessageFieldRestriction Message {
|
|
get { return HasMessage ? (global::Bgs.Protocol.MessageFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.Message;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "message" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasMessage {
|
|
get { return typeCase_ == TypeOneofCase.Message; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "message" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearMessage() {
|
|
if (HasMessage) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "entity_id" field.</summary>
|
|
public const int EntityIdFieldNumber = 7;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.EntityIdRestriction EntityId {
|
|
get { return HasEntityId ? (global::Bgs.Protocol.EntityIdRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.EntityId;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "entity_id" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasEntityId {
|
|
get { return typeCase_ == TypeOneofCase.EntityId; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "entity_id" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearEntityId() {
|
|
if (HasEntityId) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
private object type_;
|
|
/// <summary>Enum of possible cases for the "type" oneof.</summary>
|
|
public enum TypeOneofCase {
|
|
None = 0,
|
|
Signed = 1,
|
|
Unsigned = 2,
|
|
Float = 3,
|
|
String = 4,
|
|
Repeated = 5,
|
|
Message = 6,
|
|
EntityId = 7,
|
|
}
|
|
private TypeOneofCase typeCase_ = TypeOneofCase.None;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public TypeOneofCase TypeCase {
|
|
get { return typeCase_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearType() {
|
|
typeCase_ = TypeOneofCase.None;
|
|
type_ = null;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as FieldRestriction);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(FieldRestriction other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!object.Equals(Signed, other.Signed)) return false;
|
|
if (!object.Equals(Unsigned, other.Unsigned)) return false;
|
|
if (!object.Equals(Float, other.Float)) return false;
|
|
if (!object.Equals(String, other.String)) return false;
|
|
if (!object.Equals(Repeated, other.Repeated)) return false;
|
|
if (!object.Equals(Message, other.Message)) return false;
|
|
if (!object.Equals(EntityId, other.EntityId)) return false;
|
|
if (TypeCase != other.TypeCase) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasSigned) hash ^= Signed.GetHashCode();
|
|
if (HasUnsigned) hash ^= Unsigned.GetHashCode();
|
|
if (HasFloat) hash ^= Float.GetHashCode();
|
|
if (HasString) hash ^= String.GetHashCode();
|
|
if (HasRepeated) hash ^= Repeated.GetHashCode();
|
|
if (HasMessage) hash ^= Message.GetHashCode();
|
|
if (HasEntityId) hash ^= EntityId.GetHashCode();
|
|
hash ^= (int) typeCase_;
|
|
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 (HasSigned) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(Signed);
|
|
}
|
|
if (HasUnsigned) {
|
|
output.WriteRawTag(18);
|
|
output.WriteMessage(Unsigned);
|
|
}
|
|
if (HasFloat) {
|
|
output.WriteRawTag(26);
|
|
output.WriteMessage(Float);
|
|
}
|
|
if (HasString) {
|
|
output.WriteRawTag(34);
|
|
output.WriteMessage(String);
|
|
}
|
|
if (HasRepeated) {
|
|
output.WriteRawTag(42);
|
|
output.WriteMessage(Repeated);
|
|
}
|
|
if (HasMessage) {
|
|
output.WriteRawTag(50);
|
|
output.WriteMessage(Message);
|
|
}
|
|
if (HasEntityId) {
|
|
output.WriteRawTag(58);
|
|
output.WriteMessage(EntityId);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasSigned) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Signed);
|
|
}
|
|
if (HasUnsigned) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Unsigned);
|
|
}
|
|
if (HasFloat) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Float);
|
|
}
|
|
if (HasString) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(String);
|
|
}
|
|
if (HasRepeated) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Repeated);
|
|
}
|
|
if (HasMessage) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Message);
|
|
}
|
|
if (HasEntityId) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(EntityId);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(FieldRestriction other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
switch (other.TypeCase) {
|
|
case TypeOneofCase.Signed:
|
|
if (Signed == null) {
|
|
Signed = new global::Bgs.Protocol.SignedFieldRestriction();
|
|
}
|
|
Signed.MergeFrom(other.Signed);
|
|
break;
|
|
case TypeOneofCase.Unsigned:
|
|
if (Unsigned == null) {
|
|
Unsigned = new global::Bgs.Protocol.UnsignedFieldRestriction();
|
|
}
|
|
Unsigned.MergeFrom(other.Unsigned);
|
|
break;
|
|
case TypeOneofCase.Float:
|
|
if (Float == null) {
|
|
Float = new global::Bgs.Protocol.FloatFieldRestriction();
|
|
}
|
|
Float.MergeFrom(other.Float);
|
|
break;
|
|
case TypeOneofCase.String:
|
|
if (String == null) {
|
|
String = new global::Bgs.Protocol.StringFieldRestriction();
|
|
}
|
|
String.MergeFrom(other.String);
|
|
break;
|
|
case TypeOneofCase.Repeated:
|
|
if (Repeated == null) {
|
|
Repeated = new global::Bgs.Protocol.RepeatedFieldRestriction();
|
|
}
|
|
Repeated.MergeFrom(other.Repeated);
|
|
break;
|
|
case TypeOneofCase.Message:
|
|
if (Message == null) {
|
|
Message = new global::Bgs.Protocol.MessageFieldRestriction();
|
|
}
|
|
Message.MergeFrom(other.Message);
|
|
break;
|
|
case TypeOneofCase.EntityId:
|
|
if (EntityId == null) {
|
|
EntityId = new global::Bgs.Protocol.EntityIdRestriction();
|
|
}
|
|
EntityId.MergeFrom(other.EntityId);
|
|
break;
|
|
}
|
|
|
|
_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: {
|
|
global::Bgs.Protocol.SignedFieldRestriction subBuilder = new global::Bgs.Protocol.SignedFieldRestriction();
|
|
if (HasSigned) {
|
|
subBuilder.MergeFrom(Signed);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
Signed = subBuilder;
|
|
break;
|
|
}
|
|
case 18: {
|
|
global::Bgs.Protocol.UnsignedFieldRestriction subBuilder = new global::Bgs.Protocol.UnsignedFieldRestriction();
|
|
if (HasUnsigned) {
|
|
subBuilder.MergeFrom(Unsigned);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
Unsigned = subBuilder;
|
|
break;
|
|
}
|
|
case 26: {
|
|
global::Bgs.Protocol.FloatFieldRestriction subBuilder = new global::Bgs.Protocol.FloatFieldRestriction();
|
|
if (HasFloat) {
|
|
subBuilder.MergeFrom(Float);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
Float = subBuilder;
|
|
break;
|
|
}
|
|
case 34: {
|
|
global::Bgs.Protocol.StringFieldRestriction subBuilder = new global::Bgs.Protocol.StringFieldRestriction();
|
|
if (HasString) {
|
|
subBuilder.MergeFrom(String);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
String = subBuilder;
|
|
break;
|
|
}
|
|
case 42: {
|
|
global::Bgs.Protocol.RepeatedFieldRestriction subBuilder = new global::Bgs.Protocol.RepeatedFieldRestriction();
|
|
if (HasRepeated) {
|
|
subBuilder.MergeFrom(Repeated);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
Repeated = subBuilder;
|
|
break;
|
|
}
|
|
case 50: {
|
|
global::Bgs.Protocol.MessageFieldRestriction subBuilder = new global::Bgs.Protocol.MessageFieldRestriction();
|
|
if (HasMessage) {
|
|
subBuilder.MergeFrom(Message);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
Message = subBuilder;
|
|
break;
|
|
}
|
|
case 58: {
|
|
global::Bgs.Protocol.EntityIdRestriction subBuilder = new global::Bgs.Protocol.EntityIdRestriction();
|
|
if (HasEntityId) {
|
|
subBuilder.MergeFrom(EntityId);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
EntityId = subBuilder;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public sealed partial class RepeatedFieldRestriction : pb::IMessage<RepeatedFieldRestriction> {
|
|
private static readonly pb::MessageParser<RepeatedFieldRestriction> _parser = new pb::MessageParser<RepeatedFieldRestriction>(() => new RepeatedFieldRestriction());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<RepeatedFieldRestriction> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.FieldOptionsReflection.Descriptor.MessageTypes[2]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public RepeatedFieldRestriction() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public RepeatedFieldRestriction(RepeatedFieldRestriction other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
size_ = other.HasSize ? other.size_.Clone() : null;
|
|
unique_ = other.unique_;
|
|
switch (other.TypeCase) {
|
|
case TypeOneofCase.Signed:
|
|
Signed = other.Signed.Clone();
|
|
break;
|
|
case TypeOneofCase.Unsigned:
|
|
Unsigned = other.Unsigned.Clone();
|
|
break;
|
|
case TypeOneofCase.Float:
|
|
Float = other.Float.Clone();
|
|
break;
|
|
case TypeOneofCase.String:
|
|
String = other.String.Clone();
|
|
break;
|
|
case TypeOneofCase.EntityId:
|
|
EntityId = other.EntityId.Clone();
|
|
break;
|
|
}
|
|
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public RepeatedFieldRestriction Clone() {
|
|
return new RepeatedFieldRestriction(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "size" field.</summary>
|
|
public const int SizeFieldNumber = 1;
|
|
private global::Bgs.Protocol.UnsignedIntRange size_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.UnsignedIntRange Size {
|
|
get { return size_; }
|
|
set {
|
|
size_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the size field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasSize {
|
|
get { return size_ != null; }
|
|
}
|
|
/// <summary>Clears the value of the size field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearSize() {
|
|
size_ = null;
|
|
}
|
|
|
|
/// <summary>Field number for the "unique" field.</summary>
|
|
public const int UniqueFieldNumber = 2;
|
|
private readonly static bool UniqueDefaultValue = false;
|
|
|
|
private bool unique_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Unique {
|
|
get { if ((_hasBits0 & 1) != 0) { return unique_; } else { return UniqueDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
unique_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "unique" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasUnique {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "unique" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearUnique() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "signed" field.</summary>
|
|
public const int SignedFieldNumber = 3;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.SignedFieldRestriction Signed {
|
|
get { return HasSigned ? (global::Bgs.Protocol.SignedFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.Signed;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "signed" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasSigned {
|
|
get { return typeCase_ == TypeOneofCase.Signed; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "signed" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearSigned() {
|
|
if (HasSigned) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "unsigned" field.</summary>
|
|
public const int UnsignedFieldNumber = 4;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.UnsignedFieldRestriction Unsigned {
|
|
get { return HasUnsigned ? (global::Bgs.Protocol.UnsignedFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.Unsigned;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "unsigned" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasUnsigned {
|
|
get { return typeCase_ == TypeOneofCase.Unsigned; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "unsigned" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearUnsigned() {
|
|
if (HasUnsigned) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "float" field.</summary>
|
|
public const int FloatFieldNumber = 5;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.FloatFieldRestriction Float {
|
|
get { return HasFloat ? (global::Bgs.Protocol.FloatFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.Float;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "float" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasFloat {
|
|
get { return typeCase_ == TypeOneofCase.Float; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "float" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearFloat() {
|
|
if (HasFloat) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "string" field.</summary>
|
|
public const int StringFieldNumber = 6;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.StringFieldRestriction String {
|
|
get { return HasString ? (global::Bgs.Protocol.StringFieldRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.String;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "string" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasString {
|
|
get { return typeCase_ == TypeOneofCase.String; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "string" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearString() {
|
|
if (HasString) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
/// <summary>Field number for the "entity_id" field.</summary>
|
|
public const int EntityIdFieldNumber = 7;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.EntityIdRestriction EntityId {
|
|
get { return HasEntityId ? (global::Bgs.Protocol.EntityIdRestriction) type_ : null; }
|
|
set {
|
|
type_ = value;
|
|
typeCase_ = value == null ? TypeOneofCase.None : TypeOneofCase.EntityId;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "entity_id" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasEntityId {
|
|
get { return typeCase_ == TypeOneofCase.EntityId; }
|
|
}
|
|
/// <summary> Clears the value of the oneof if it's currently set to "entity_id" </summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearEntityId() {
|
|
if (HasEntityId) {
|
|
ClearType();
|
|
}
|
|
}
|
|
|
|
private object type_;
|
|
/// <summary>Enum of possible cases for the "type" oneof.</summary>
|
|
public enum TypeOneofCase {
|
|
None = 0,
|
|
Signed = 3,
|
|
Unsigned = 4,
|
|
Float = 5,
|
|
String = 6,
|
|
EntityId = 7,
|
|
}
|
|
private TypeOneofCase typeCase_ = TypeOneofCase.None;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public TypeOneofCase TypeCase {
|
|
get { return typeCase_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearType() {
|
|
typeCase_ = TypeOneofCase.None;
|
|
type_ = null;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as RepeatedFieldRestriction);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(RepeatedFieldRestriction other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!object.Equals(Size, other.Size)) return false;
|
|
if (Unique != other.Unique) return false;
|
|
if (!object.Equals(Signed, other.Signed)) return false;
|
|
if (!object.Equals(Unsigned, other.Unsigned)) return false;
|
|
if (!object.Equals(Float, other.Float)) return false;
|
|
if (!object.Equals(String, other.String)) return false;
|
|
if (!object.Equals(EntityId, other.EntityId)) return false;
|
|
if (TypeCase != other.TypeCase) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasSize) hash ^= Size.GetHashCode();
|
|
if (HasUnique) hash ^= Unique.GetHashCode();
|
|
if (HasSigned) hash ^= Signed.GetHashCode();
|
|
if (HasUnsigned) hash ^= Unsigned.GetHashCode();
|
|
if (HasFloat) hash ^= Float.GetHashCode();
|
|
if (HasString) hash ^= String.GetHashCode();
|
|
if (HasEntityId) hash ^= EntityId.GetHashCode();
|
|
hash ^= (int) typeCase_;
|
|
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 (HasSize) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(Size);
|
|
}
|
|
if (HasUnique) {
|
|
output.WriteRawTag(16);
|
|
output.WriteBool(Unique);
|
|
}
|
|
if (HasSigned) {
|
|
output.WriteRawTag(26);
|
|
output.WriteMessage(Signed);
|
|
}
|
|
if (HasUnsigned) {
|
|
output.WriteRawTag(34);
|
|
output.WriteMessage(Unsigned);
|
|
}
|
|
if (HasFloat) {
|
|
output.WriteRawTag(42);
|
|
output.WriteMessage(Float);
|
|
}
|
|
if (HasString) {
|
|
output.WriteRawTag(50);
|
|
output.WriteMessage(String);
|
|
}
|
|
if (HasEntityId) {
|
|
output.WriteRawTag(58);
|
|
output.WriteMessage(EntityId);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasSize) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Size);
|
|
}
|
|
if (HasUnique) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasSigned) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Signed);
|
|
}
|
|
if (HasUnsigned) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Unsigned);
|
|
}
|
|
if (HasFloat) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Float);
|
|
}
|
|
if (HasString) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(String);
|
|
}
|
|
if (HasEntityId) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(EntityId);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(RepeatedFieldRestriction other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasSize) {
|
|
if (!HasSize) {
|
|
Size = new global::Bgs.Protocol.UnsignedIntRange();
|
|
}
|
|
Size.MergeFrom(other.Size);
|
|
}
|
|
if (other.HasUnique) {
|
|
Unique = other.Unique;
|
|
}
|
|
switch (other.TypeCase) {
|
|
case TypeOneofCase.Signed:
|
|
if (Signed == null) {
|
|
Signed = new global::Bgs.Protocol.SignedFieldRestriction();
|
|
}
|
|
Signed.MergeFrom(other.Signed);
|
|
break;
|
|
case TypeOneofCase.Unsigned:
|
|
if (Unsigned == null) {
|
|
Unsigned = new global::Bgs.Protocol.UnsignedFieldRestriction();
|
|
}
|
|
Unsigned.MergeFrom(other.Unsigned);
|
|
break;
|
|
case TypeOneofCase.Float:
|
|
if (Float == null) {
|
|
Float = new global::Bgs.Protocol.FloatFieldRestriction();
|
|
}
|
|
Float.MergeFrom(other.Float);
|
|
break;
|
|
case TypeOneofCase.String:
|
|
if (String == null) {
|
|
String = new global::Bgs.Protocol.StringFieldRestriction();
|
|
}
|
|
String.MergeFrom(other.String);
|
|
break;
|
|
case TypeOneofCase.EntityId:
|
|
if (EntityId == null) {
|
|
EntityId = new global::Bgs.Protocol.EntityIdRestriction();
|
|
}
|
|
EntityId.MergeFrom(other.EntityId);
|
|
break;
|
|
}
|
|
|
|
_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: {
|
|
if (!HasSize) {
|
|
Size = new global::Bgs.Protocol.UnsignedIntRange();
|
|
}
|
|
input.ReadMessage(Size);
|
|
break;
|
|
}
|
|
case 16: {
|
|
Unique = input.ReadBool();
|
|
break;
|
|
}
|
|
case 26: {
|
|
global::Bgs.Protocol.SignedFieldRestriction subBuilder = new global::Bgs.Protocol.SignedFieldRestriction();
|
|
if (HasSigned) {
|
|
subBuilder.MergeFrom(Signed);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
Signed = subBuilder;
|
|
break;
|
|
}
|
|
case 34: {
|
|
global::Bgs.Protocol.UnsignedFieldRestriction subBuilder = new global::Bgs.Protocol.UnsignedFieldRestriction();
|
|
if (HasUnsigned) {
|
|
subBuilder.MergeFrom(Unsigned);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
Unsigned = subBuilder;
|
|
break;
|
|
}
|
|
case 42: {
|
|
global::Bgs.Protocol.FloatFieldRestriction subBuilder = new global::Bgs.Protocol.FloatFieldRestriction();
|
|
if (HasFloat) {
|
|
subBuilder.MergeFrom(Float);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
Float = subBuilder;
|
|
break;
|
|
}
|
|
case 50: {
|
|
global::Bgs.Protocol.StringFieldRestriction subBuilder = new global::Bgs.Protocol.StringFieldRestriction();
|
|
if (HasString) {
|
|
subBuilder.MergeFrom(String);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
String = subBuilder;
|
|
break;
|
|
}
|
|
case 58: {
|
|
global::Bgs.Protocol.EntityIdRestriction subBuilder = new global::Bgs.Protocol.EntityIdRestriction();
|
|
if (HasEntityId) {
|
|
subBuilder.MergeFrom(EntityId);
|
|
}
|
|
input.ReadMessage(subBuilder);
|
|
EntityId = subBuilder;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public sealed partial class SignedFieldRestriction : pb::IMessage<SignedFieldRestriction> {
|
|
private static readonly pb::MessageParser<SignedFieldRestriction> _parser = new pb::MessageParser<SignedFieldRestriction>(() => new SignedFieldRestriction());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<SignedFieldRestriction> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.FieldOptionsReflection.Descriptor.MessageTypes[3]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public SignedFieldRestriction() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public SignedFieldRestriction(SignedFieldRestriction other) : this() {
|
|
limits_ = other.HasLimits ? other.limits_.Clone() : null;
|
|
exclude_ = other.exclude_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public SignedFieldRestriction Clone() {
|
|
return new SignedFieldRestriction(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "limits" field.</summary>
|
|
public const int LimitsFieldNumber = 1;
|
|
private global::Bgs.Protocol.SignedIntRange limits_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.SignedIntRange Limits {
|
|
get { return limits_; }
|
|
set {
|
|
limits_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the limits field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasLimits {
|
|
get { return limits_ != null; }
|
|
}
|
|
/// <summary>Clears the value of the limits field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearLimits() {
|
|
limits_ = null;
|
|
}
|
|
|
|
/// <summary>Field number for the "exclude" field.</summary>
|
|
public const int ExcludeFieldNumber = 2;
|
|
private static readonly pb::FieldCodec<long> _repeated_exclude_codec
|
|
= pb::FieldCodec.ForSInt64(16);
|
|
private readonly pbc::RepeatedField<long> exclude_ = new pbc::RepeatedField<long>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public pbc::RepeatedField<long> Exclude {
|
|
get { return exclude_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as SignedFieldRestriction);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(SignedFieldRestriction other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!object.Equals(Limits, other.Limits)) return false;
|
|
if(!exclude_.Equals(other.exclude_)) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasLimits) hash ^= Limits.GetHashCode();
|
|
hash ^= exclude_.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 (HasLimits) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(Limits);
|
|
}
|
|
exclude_.WriteTo(output, _repeated_exclude_codec);
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasLimits) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Limits);
|
|
}
|
|
size += exclude_.CalculateSize(_repeated_exclude_codec);
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(SignedFieldRestriction other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasLimits) {
|
|
if (!HasLimits) {
|
|
Limits = new global::Bgs.Protocol.SignedIntRange();
|
|
}
|
|
Limits.MergeFrom(other.Limits);
|
|
}
|
|
exclude_.Add(other.exclude_);
|
|
_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: {
|
|
if (!HasLimits) {
|
|
Limits = new global::Bgs.Protocol.SignedIntRange();
|
|
}
|
|
input.ReadMessage(Limits);
|
|
break;
|
|
}
|
|
case 18:
|
|
case 16: {
|
|
exclude_.AddEntriesFrom(input, _repeated_exclude_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public sealed partial class UnsignedFieldRestriction : pb::IMessage<UnsignedFieldRestriction> {
|
|
private static readonly pb::MessageParser<UnsignedFieldRestriction> _parser = new pb::MessageParser<UnsignedFieldRestriction>(() => new UnsignedFieldRestriction());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<UnsignedFieldRestriction> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.FieldOptionsReflection.Descriptor.MessageTypes[4]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public UnsignedFieldRestriction() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public UnsignedFieldRestriction(UnsignedFieldRestriction other) : this() {
|
|
limits_ = other.HasLimits ? other.limits_.Clone() : null;
|
|
exclude_ = other.exclude_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public UnsignedFieldRestriction Clone() {
|
|
return new UnsignedFieldRestriction(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "limits" field.</summary>
|
|
public const int LimitsFieldNumber = 1;
|
|
private global::Bgs.Protocol.UnsignedIntRange limits_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.UnsignedIntRange Limits {
|
|
get { return limits_; }
|
|
set {
|
|
limits_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the limits field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasLimits {
|
|
get { return limits_ != null; }
|
|
}
|
|
/// <summary>Clears the value of the limits field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearLimits() {
|
|
limits_ = null;
|
|
}
|
|
|
|
/// <summary>Field number for the "exclude" field.</summary>
|
|
public const int ExcludeFieldNumber = 2;
|
|
private static readonly pb::FieldCodec<ulong> _repeated_exclude_codec
|
|
= pb::FieldCodec.ForUInt64(16);
|
|
private readonly pbc::RepeatedField<ulong> exclude_ = new pbc::RepeatedField<ulong>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public pbc::RepeatedField<ulong> Exclude {
|
|
get { return exclude_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as UnsignedFieldRestriction);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(UnsignedFieldRestriction other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!object.Equals(Limits, other.Limits)) return false;
|
|
if(!exclude_.Equals(other.exclude_)) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasLimits) hash ^= Limits.GetHashCode();
|
|
hash ^= exclude_.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 (HasLimits) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(Limits);
|
|
}
|
|
exclude_.WriteTo(output, _repeated_exclude_codec);
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasLimits) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Limits);
|
|
}
|
|
size += exclude_.CalculateSize(_repeated_exclude_codec);
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(UnsignedFieldRestriction other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasLimits) {
|
|
if (!HasLimits) {
|
|
Limits = new global::Bgs.Protocol.UnsignedIntRange();
|
|
}
|
|
Limits.MergeFrom(other.Limits);
|
|
}
|
|
exclude_.Add(other.exclude_);
|
|
_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: {
|
|
if (!HasLimits) {
|
|
Limits = new global::Bgs.Protocol.UnsignedIntRange();
|
|
}
|
|
input.ReadMessage(Limits);
|
|
break;
|
|
}
|
|
case 18:
|
|
case 16: {
|
|
exclude_.AddEntriesFrom(input, _repeated_exclude_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public sealed partial class FloatFieldRestriction : pb::IMessage<FloatFieldRestriction> {
|
|
private static readonly pb::MessageParser<FloatFieldRestriction> _parser = new pb::MessageParser<FloatFieldRestriction>(() => new FloatFieldRestriction());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<FloatFieldRestriction> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.FieldOptionsReflection.Descriptor.MessageTypes[5]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public FloatFieldRestriction() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public FloatFieldRestriction(FloatFieldRestriction other) : this() {
|
|
limits_ = other.HasLimits ? other.limits_.Clone() : null;
|
|
exclude_ = other.exclude_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public FloatFieldRestriction Clone() {
|
|
return new FloatFieldRestriction(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "limits" field.</summary>
|
|
public const int LimitsFieldNumber = 1;
|
|
private global::Bgs.Protocol.FloatRange limits_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.FloatRange Limits {
|
|
get { return limits_; }
|
|
set {
|
|
limits_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the limits field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasLimits {
|
|
get { return limits_ != null; }
|
|
}
|
|
/// <summary>Clears the value of the limits field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearLimits() {
|
|
limits_ = null;
|
|
}
|
|
|
|
/// <summary>Field number for the "exclude" field.</summary>
|
|
public const int ExcludeFieldNumber = 2;
|
|
private static readonly pb::FieldCodec<float> _repeated_exclude_codec
|
|
= pb::FieldCodec.ForFloat(21);
|
|
private readonly pbc::RepeatedField<float> exclude_ = new pbc::RepeatedField<float>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public pbc::RepeatedField<float> Exclude {
|
|
get { return exclude_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as FloatFieldRestriction);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(FloatFieldRestriction other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!object.Equals(Limits, other.Limits)) return false;
|
|
if(!exclude_.Equals(other.exclude_)) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasLimits) hash ^= Limits.GetHashCode();
|
|
hash ^= exclude_.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 (HasLimits) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(Limits);
|
|
}
|
|
exclude_.WriteTo(output, _repeated_exclude_codec);
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasLimits) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Limits);
|
|
}
|
|
size += exclude_.CalculateSize(_repeated_exclude_codec);
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(FloatFieldRestriction other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasLimits) {
|
|
if (!HasLimits) {
|
|
Limits = new global::Bgs.Protocol.FloatRange();
|
|
}
|
|
Limits.MergeFrom(other.Limits);
|
|
}
|
|
exclude_.Add(other.exclude_);
|
|
_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: {
|
|
if (!HasLimits) {
|
|
Limits = new global::Bgs.Protocol.FloatRange();
|
|
}
|
|
input.ReadMessage(Limits);
|
|
break;
|
|
}
|
|
case 18:
|
|
case 21: {
|
|
exclude_.AddEntriesFrom(input, _repeated_exclude_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public sealed partial class StringFieldRestriction : pb::IMessage<StringFieldRestriction> {
|
|
private static readonly pb::MessageParser<StringFieldRestriction> _parser = new pb::MessageParser<StringFieldRestriction>(() => new StringFieldRestriction());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<StringFieldRestriction> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.FieldOptionsReflection.Descriptor.MessageTypes[6]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public StringFieldRestriction() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public StringFieldRestriction(StringFieldRestriction other) : this() {
|
|
size_ = other.HasSize ? other.size_.Clone() : null;
|
|
exclude_ = other.exclude_.Clone();
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public StringFieldRestriction Clone() {
|
|
return new StringFieldRestriction(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "size" field.</summary>
|
|
public const int SizeFieldNumber = 1;
|
|
private global::Bgs.Protocol.UnsignedIntRange size_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.UnsignedIntRange Size {
|
|
get { return size_; }
|
|
set {
|
|
size_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the size field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasSize {
|
|
get { return size_ != null; }
|
|
}
|
|
/// <summary>Clears the value of the size field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearSize() {
|
|
size_ = null;
|
|
}
|
|
|
|
/// <summary>Field number for the "exclude" field.</summary>
|
|
public const int ExcludeFieldNumber = 2;
|
|
private static readonly pb::FieldCodec<string> _repeated_exclude_codec
|
|
= pb::FieldCodec.ForString(18);
|
|
private readonly pbc::RepeatedField<string> exclude_ = new pbc::RepeatedField<string>();
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public pbc::RepeatedField<string> Exclude {
|
|
get { return exclude_; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as StringFieldRestriction);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(StringFieldRestriction other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (!object.Equals(Size, other.Size)) return false;
|
|
if(!exclude_.Equals(other.exclude_)) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasSize) hash ^= Size.GetHashCode();
|
|
hash ^= exclude_.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 (HasSize) {
|
|
output.WriteRawTag(10);
|
|
output.WriteMessage(Size);
|
|
}
|
|
exclude_.WriteTo(output, _repeated_exclude_codec);
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasSize) {
|
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Size);
|
|
}
|
|
size += exclude_.CalculateSize(_repeated_exclude_codec);
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(StringFieldRestriction other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasSize) {
|
|
if (!HasSize) {
|
|
Size = new global::Bgs.Protocol.UnsignedIntRange();
|
|
}
|
|
Size.MergeFrom(other.Size);
|
|
}
|
|
exclude_.Add(other.exclude_);
|
|
_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: {
|
|
if (!HasSize) {
|
|
Size = new global::Bgs.Protocol.UnsignedIntRange();
|
|
}
|
|
input.ReadMessage(Size);
|
|
break;
|
|
}
|
|
case 18: {
|
|
exclude_.AddEntriesFrom(input, _repeated_exclude_codec);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public sealed partial class EntityIdRestriction : pb::IMessage<EntityIdRestriction> {
|
|
private static readonly pb::MessageParser<EntityIdRestriction> _parser = new pb::MessageParser<EntityIdRestriction>(() => new EntityIdRestriction());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<EntityIdRestriction> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.FieldOptionsReflection.Descriptor.MessageTypes[7]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public EntityIdRestriction() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public EntityIdRestriction(EntityIdRestriction other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
needed_ = other.needed_;
|
|
kind_ = other.kind_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public EntityIdRestriction Clone() {
|
|
return new EntityIdRestriction(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "needed" field.</summary>
|
|
public const int NeededFieldNumber = 1;
|
|
private readonly static bool NeededDefaultValue = false;
|
|
|
|
private bool needed_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Needed {
|
|
get { if ((_hasBits0 & 1) != 0) { return needed_; } else { return NeededDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
needed_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "needed" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasNeeded {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "needed" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearNeeded() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
/// <summary>Field number for the "kind" field.</summary>
|
|
public const int KindFieldNumber = 2;
|
|
private readonly static global::Bgs.Protocol.EntityIdRestriction.Types.Kind KindDefaultValue = global::Bgs.Protocol.EntityIdRestriction.Types.Kind.Any;
|
|
|
|
private global::Bgs.Protocol.EntityIdRestriction.Types.Kind kind_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public global::Bgs.Protocol.EntityIdRestriction.Types.Kind Kind {
|
|
get { if ((_hasBits0 & 2) != 0) { return kind_; } else { return KindDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 2;
|
|
kind_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "kind" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasKind {
|
|
get { return (_hasBits0 & 2) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "kind" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearKind() {
|
|
_hasBits0 &= ~2;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as EntityIdRestriction);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(EntityIdRestriction other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (Needed != other.Needed) return false;
|
|
if (Kind != other.Kind) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasNeeded) hash ^= Needed.GetHashCode();
|
|
if (HasKind) hash ^= Kind.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 (HasNeeded) {
|
|
output.WriteRawTag(8);
|
|
output.WriteBool(Needed);
|
|
}
|
|
if (HasKind) {
|
|
output.WriteRawTag(16);
|
|
output.WriteEnum((int) Kind);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasNeeded) {
|
|
size += 1 + 1;
|
|
}
|
|
if (HasKind) {
|
|
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Kind);
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(EntityIdRestriction other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasNeeded) {
|
|
Needed = other.Needed;
|
|
}
|
|
if (other.HasKind) {
|
|
Kind = other.Kind;
|
|
}
|
|
_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 8: {
|
|
Needed = input.ReadBool();
|
|
break;
|
|
}
|
|
case 16: {
|
|
Kind = (global::Bgs.Protocol.EntityIdRestriction.Types.Kind) input.ReadEnum();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Nested types
|
|
/// <summary>Container for nested types declared in the EntityIdRestriction message type.</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static partial class Types {
|
|
public enum Kind {
|
|
[pbr::OriginalName("ANY")] Any = 0,
|
|
[pbr::OriginalName("ACCOUNT")] Account = 1,
|
|
[pbr::OriginalName("GAME_ACCOUNT")] GameAccount = 2,
|
|
[pbr::OriginalName("ACCOUNT_OR_GAME_ACCOUNT")] AccountOrGameAccount = 3,
|
|
[pbr::OriginalName("SERVICE")] Service = 4,
|
|
[pbr::OriginalName("CHANNEL")] Channel = 5,
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
|
|
public sealed partial class MessageFieldRestriction : pb::IMessage<MessageFieldRestriction> {
|
|
private static readonly pb::MessageParser<MessageFieldRestriction> _parser = new pb::MessageParser<MessageFieldRestriction>(() => new MessageFieldRestriction());
|
|
private pb::UnknownFieldSet _unknownFields;
|
|
private int _hasBits0;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pb::MessageParser<MessageFieldRestriction> Parser { get { return _parser; } }
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public static pbr::MessageDescriptor Descriptor {
|
|
get { return global::Bgs.Protocol.FieldOptionsReflection.Descriptor.MessageTypes[8]; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
pbr::MessageDescriptor pb::IMessage.Descriptor {
|
|
get { return Descriptor; }
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public MessageFieldRestriction() {
|
|
OnConstruction();
|
|
}
|
|
|
|
partial void OnConstruction();
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public MessageFieldRestriction(MessageFieldRestriction other) : this() {
|
|
_hasBits0 = other._hasBits0;
|
|
needed_ = other.needed_;
|
|
_unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public MessageFieldRestriction Clone() {
|
|
return new MessageFieldRestriction(this);
|
|
}
|
|
|
|
/// <summary>Field number for the "needed" field.</summary>
|
|
public const int NeededFieldNumber = 1;
|
|
private readonly static bool NeededDefaultValue = false;
|
|
|
|
private bool needed_;
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Needed {
|
|
get { if ((_hasBits0 & 1) != 0) { return needed_; } else { return NeededDefaultValue; } }
|
|
set {
|
|
_hasBits0 |= 1;
|
|
needed_ = value;
|
|
}
|
|
}
|
|
/// <summary>Gets whether the "needed" field is set</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool HasNeeded {
|
|
get { return (_hasBits0 & 1) != 0; }
|
|
}
|
|
/// <summary>Clears the value of the "needed" field</summary>
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void ClearNeeded() {
|
|
_hasBits0 &= ~1;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override bool Equals(object other) {
|
|
return Equals(other as MessageFieldRestriction);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public bool Equals(MessageFieldRestriction other) {
|
|
if (ReferenceEquals(other, null)) {
|
|
return false;
|
|
}
|
|
if (ReferenceEquals(other, this)) {
|
|
return true;
|
|
}
|
|
if (Needed != other.Needed) return false;
|
|
return Equals(_unknownFields, other._unknownFields);
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public override int GetHashCode() {
|
|
int hash = 1;
|
|
if (HasNeeded) hash ^= Needed.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 (HasNeeded) {
|
|
output.WriteRawTag(8);
|
|
output.WriteBool(Needed);
|
|
}
|
|
if (_unknownFields != null) {
|
|
_unknownFields.WriteTo(output);
|
|
}
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public int CalculateSize() {
|
|
int size = 0;
|
|
if (HasNeeded) {
|
|
size += 1 + 1;
|
|
}
|
|
if (_unknownFields != null) {
|
|
size += _unknownFields.CalculateSize();
|
|
}
|
|
return size;
|
|
}
|
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
|
|
public void MergeFrom(MessageFieldRestriction other) {
|
|
if (other == null) {
|
|
return;
|
|
}
|
|
if (other.HasNeeded) {
|
|
Needed = other.Needed;
|
|
}
|
|
_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 8: {
|
|
Needed = input.ReadBool();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
#endregion Designer generated code
|