| // <auto-generated> |
| // Generated by the protocol buffer compiler. DO NOT EDIT! |
| // source: google/protobuf/compiler/plugin.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 Google.Protobuf.Compiler { |
| |
| /// <summary>Holder for reflection information generated from google/protobuf/compiler/plugin.proto</summary> |
| public static partial class PluginReflection { |
| |
| #region Descriptor |
| /// <summary>File descriptor for google/protobuf/compiler/plugin.proto</summary> |
| public static pbr::FileDescriptor Descriptor { |
| get { return descriptor; } |
| } |
| private static pbr::FileDescriptor descriptor; |
| |
| static PluginReflection() { |
| byte[] descriptorData = global::System.Convert.FromBase64String( |
| string.Concat( |
| "CiVnb29nbGUvcHJvdG9idWYvY29tcGlsZXIvcGx1Z2luLnByb3RvEhhnb29n", |
| "bGUucHJvdG9idWYuY29tcGlsZXIaIGdvb2dsZS9wcm90b2J1Zi9kZXNjcmlw", |
| "dG9yLnByb3RvIkYKB1ZlcnNpb24SDQoFbWFqb3IYASABKAUSDQoFbWlub3IY", |
| "AiABKAUSDQoFcGF0Y2gYAyABKAUSDgoGc3VmZml4GAQgASgJIoECChRDb2Rl", |
| "R2VuZXJhdG9yUmVxdWVzdBIYChBmaWxlX3RvX2dlbmVyYXRlGAEgAygJEhEK", |
| "CXBhcmFtZXRlchgCIAEoCRI4Cgpwcm90b19maWxlGA8gAygLMiQuZ29vZ2xl", |
| "LnByb3RvYnVmLkZpbGVEZXNjcmlwdG9yUHJvdG8SRQoXc291cmNlX2ZpbGVf", |
| "ZGVzY3JpcHRvcnMYESADKAsyJC5nb29nbGUucHJvdG9idWYuRmlsZURlc2Ny", |
| "aXB0b3JQcm90bxI7ChBjb21waWxlcl92ZXJzaW9uGAMgASgLMiEuZ29vZ2xl", |
| "LnByb3RvYnVmLmNvbXBpbGVyLlZlcnNpb24ikgMKFUNvZGVHZW5lcmF0b3JS", |
| "ZXNwb25zZRINCgVlcnJvchgBIAEoCRIaChJzdXBwb3J0ZWRfZmVhdHVyZXMY", |
| "AiABKAQSFwoPbWluaW11bV9lZGl0aW9uGAMgASgFEhcKD21heGltdW1fZWRp", |
| "dGlvbhgEIAEoBRJCCgRmaWxlGA8gAygLMjQuZ29vZ2xlLnByb3RvYnVmLmNv", |
| "bXBpbGVyLkNvZGVHZW5lcmF0b3JSZXNwb25zZS5GaWxlGn8KBEZpbGUSDAoE", |
| "bmFtZRgBIAEoCRIXCg9pbnNlcnRpb25fcG9pbnQYAiABKAkSDwoHY29udGVu", |
| "dBgPIAEoCRI/ChNnZW5lcmF0ZWRfY29kZV9pbmZvGBAgASgLMiIuZ29vZ2xl", |
| "LnByb3RvYnVmLkdlbmVyYXRlZENvZGVJbmZvIlcKB0ZlYXR1cmUSEAoMRkVB", |
| "VFVSRV9OT05FEAASGwoXRkVBVFVSRV9QUk9UTzNfT1BUSU9OQUwQARIdChlG", |
| "RUFUVVJFX1NVUFBPUlRTX0VESVRJT05TEAJCcgocY29tLmdvb2dsZS5wcm90", |
| "b2J1Zi5jb21waWxlckIMUGx1Z2luUHJvdG9zWilnb29nbGUuZ29sYW5nLm9y", |
| "Zy9wcm90b2J1Zi90eXBlcy9wbHVnaW5wYqoCGEdvb2dsZS5Qcm90b2J1Zi5D", |
| "b21waWxlcg==")); |
| descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, |
| new pbr::FileDescriptor[] { global::Google.Protobuf.Reflection.DescriptorReflection.Descriptor, }, |
| new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { |
| new pbr::GeneratedClrTypeInfo(typeof(global::Google.Protobuf.Compiler.Version), global::Google.Protobuf.Compiler.Version.Parser, new[]{ "Major", "Minor", "Patch", "Suffix" }, null, null, null, null), |
| new pbr::GeneratedClrTypeInfo(typeof(global::Google.Protobuf.Compiler.CodeGeneratorRequest), global::Google.Protobuf.Compiler.CodeGeneratorRequest.Parser, new[]{ "FileToGenerate", "Parameter", "ProtoFile", "SourceFileDescriptors", "CompilerVersion" }, null, null, null, null), |
| new pbr::GeneratedClrTypeInfo(typeof(global::Google.Protobuf.Compiler.CodeGeneratorResponse), global::Google.Protobuf.Compiler.CodeGeneratorResponse.Parser, new[]{ "Error", "SupportedFeatures", "MinimumEdition", "MaximumEdition", "File" }, null, new[]{ typeof(global::Google.Protobuf.Compiler.CodeGeneratorResponse.Types.Feature) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Google.Protobuf.Compiler.CodeGeneratorResponse.Types.File), global::Google.Protobuf.Compiler.CodeGeneratorResponse.Types.File.Parser, new[]{ "Name", "InsertionPoint", "Content", "GeneratedCodeInfo" }, null, null, null, null)}) |
| })); |
| } |
| #endregion |
| |
| } |
| #region Messages |
| /// <summary> |
| /// The version number of protocol compiler. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] |
| public sealed partial class Version : pb::IMessage<Version> |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| , pb::IBufferMessage |
| #endif |
| { |
| private static readonly pb::MessageParser<Version> _parser = new pb::MessageParser<Version>(() => new Version()); |
| private pb::UnknownFieldSet _unknownFields; |
| private int _hasBits0; |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public static pb::MessageParser<Version> Parser { get { return _parser; } } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public static pbr::MessageDescriptor Descriptor { |
| get { return global::Google.Protobuf.Compiler.PluginReflection.Descriptor.MessageTypes[0]; } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| pbr::MessageDescriptor pb::IMessage.Descriptor { |
| get { return Descriptor; } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public Version() { |
| OnConstruction(); |
| } |
| |
| partial void OnConstruction(); |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public Version(Version other) : this() { |
| _hasBits0 = other._hasBits0; |
| major_ = other.major_; |
| minor_ = other.minor_; |
| patch_ = other.patch_; |
| suffix_ = other.suffix_; |
| _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public Version Clone() { |
| return new Version(this); |
| } |
| |
| /// <summary>Field number for the "major" field.</summary> |
| public const int MajorFieldNumber = 1; |
| private readonly static int MajorDefaultValue = 0; |
| |
| private int major_; |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public int Major { |
| get { if ((_hasBits0 & 1) != 0) { return major_; } else { return MajorDefaultValue; } } |
| set { |
| _hasBits0 |= 1; |
| major_ = value; |
| } |
| } |
| /// <summary>Gets whether the "major" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasMajor { |
| get { return (_hasBits0 & 1) != 0; } |
| } |
| /// <summary>Clears the value of the "major" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearMajor() { |
| _hasBits0 &= ~1; |
| } |
| |
| /// <summary>Field number for the "minor" field.</summary> |
| public const int MinorFieldNumber = 2; |
| private readonly static int MinorDefaultValue = 0; |
| |
| private int minor_; |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public int Minor { |
| get { if ((_hasBits0 & 2) != 0) { return minor_; } else { return MinorDefaultValue; } } |
| set { |
| _hasBits0 |= 2; |
| minor_ = value; |
| } |
| } |
| /// <summary>Gets whether the "minor" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasMinor { |
| get { return (_hasBits0 & 2) != 0; } |
| } |
| /// <summary>Clears the value of the "minor" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearMinor() { |
| _hasBits0 &= ~2; |
| } |
| |
| /// <summary>Field number for the "patch" field.</summary> |
| public const int PatchFieldNumber = 3; |
| private readonly static int PatchDefaultValue = 0; |
| |
| private int patch_; |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public int Patch { |
| get { if ((_hasBits0 & 4) != 0) { return patch_; } else { return PatchDefaultValue; } } |
| set { |
| _hasBits0 |= 4; |
| patch_ = value; |
| } |
| } |
| /// <summary>Gets whether the "patch" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasPatch { |
| get { return (_hasBits0 & 4) != 0; } |
| } |
| /// <summary>Clears the value of the "patch" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearPatch() { |
| _hasBits0 &= ~4; |
| } |
| |
| /// <summary>Field number for the "suffix" field.</summary> |
| public const int SuffixFieldNumber = 4; |
| private readonly static string SuffixDefaultValue = ""; |
| |
| private string suffix_; |
| /// <summary> |
| /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should |
| /// be empty for mainline stable releases. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public string Suffix { |
| get { return suffix_ ?? SuffixDefaultValue; } |
| set { |
| suffix_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); |
| } |
| } |
| /// <summary>Gets whether the "suffix" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasSuffix { |
| get { return suffix_ != null; } |
| } |
| /// <summary>Clears the value of the "suffix" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearSuffix() { |
| suffix_ = null; |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override bool Equals(object other) { |
| return Equals(other as Version); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool Equals(Version other) { |
| if (ReferenceEquals(other, null)) { |
| return false; |
| } |
| if (ReferenceEquals(other, this)) { |
| return true; |
| } |
| if (Major != other.Major) return false; |
| if (Minor != other.Minor) return false; |
| if (Patch != other.Patch) return false; |
| if (Suffix != other.Suffix) return false; |
| return Equals(_unknownFields, other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override int GetHashCode() { |
| int hash = 1; |
| if (HasMajor) hash ^= Major.GetHashCode(); |
| if (HasMinor) hash ^= Minor.GetHashCode(); |
| if (HasPatch) hash ^= Patch.GetHashCode(); |
| if (HasSuffix) hash ^= Suffix.GetHashCode(); |
| if (_unknownFields != null) { |
| hash ^= _unknownFields.GetHashCode(); |
| } |
| return hash; |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override string ToString() { |
| return pb::JsonFormatter.ToDiagnosticString(this); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void WriteTo(pb::CodedOutputStream output) { |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| output.WriteRawMessage(this); |
| #else |
| if (HasMajor) { |
| output.WriteRawTag(8); |
| output.WriteInt32(Major); |
| } |
| if (HasMinor) { |
| output.WriteRawTag(16); |
| output.WriteInt32(Minor); |
| } |
| if (HasPatch) { |
| output.WriteRawTag(24); |
| output.WriteInt32(Patch); |
| } |
| if (HasSuffix) { |
| output.WriteRawTag(34); |
| output.WriteString(Suffix); |
| } |
| if (_unknownFields != null) { |
| _unknownFields.WriteTo(output); |
| } |
| #endif |
| } |
| |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { |
| if (HasMajor) { |
| output.WriteRawTag(8); |
| output.WriteInt32(Major); |
| } |
| if (HasMinor) { |
| output.WriteRawTag(16); |
| output.WriteInt32(Minor); |
| } |
| if (HasPatch) { |
| output.WriteRawTag(24); |
| output.WriteInt32(Patch); |
| } |
| if (HasSuffix) { |
| output.WriteRawTag(34); |
| output.WriteString(Suffix); |
| } |
| if (_unknownFields != null) { |
| _unknownFields.WriteTo(ref output); |
| } |
| } |
| #endif |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public int CalculateSize() { |
| int size = 0; |
| if (HasMajor) { |
| size += 1 + pb::CodedOutputStream.ComputeInt32Size(Major); |
| } |
| if (HasMinor) { |
| size += 1 + pb::CodedOutputStream.ComputeInt32Size(Minor); |
| } |
| if (HasPatch) { |
| size += 1 + pb::CodedOutputStream.ComputeInt32Size(Patch); |
| } |
| if (HasSuffix) { |
| size += 1 + pb::CodedOutputStream.ComputeStringSize(Suffix); |
| } |
| if (_unknownFields != null) { |
| size += _unknownFields.CalculateSize(); |
| } |
| return size; |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void MergeFrom(Version other) { |
| if (other == null) { |
| return; |
| } |
| if (other.HasMajor) { |
| Major = other.Major; |
| } |
| if (other.HasMinor) { |
| Minor = other.Minor; |
| } |
| if (other.HasPatch) { |
| Patch = other.Patch; |
| } |
| if (other.HasSuffix) { |
| Suffix = other.Suffix; |
| } |
| _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void MergeFrom(pb::CodedInputStream input) { |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| input.ReadRawMessage(this); |
| #else |
| uint tag; |
| while ((tag = input.ReadTag()) != 0) { |
| if ((tag & 7) == 4) { |
| // Abort on any end group tag. |
| return; |
| } |
| switch(tag) { |
| default: |
| _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); |
| break; |
| case 8: { |
| Major = input.ReadInt32(); |
| break; |
| } |
| case 16: { |
| Minor = input.ReadInt32(); |
| break; |
| } |
| case 24: { |
| Patch = input.ReadInt32(); |
| break; |
| } |
| case 34: { |
| Suffix = input.ReadString(); |
| break; |
| } |
| } |
| } |
| #endif |
| } |
| |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { |
| uint tag; |
| while ((tag = input.ReadTag()) != 0) { |
| if ((tag & 7) == 4) { |
| // Abort on any end group tag. |
| return; |
| } |
| switch(tag) { |
| default: |
| _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); |
| break; |
| case 8: { |
| Major = input.ReadInt32(); |
| break; |
| } |
| case 16: { |
| Minor = input.ReadInt32(); |
| break; |
| } |
| case 24: { |
| Patch = input.ReadInt32(); |
| break; |
| } |
| case 34: { |
| Suffix = input.ReadString(); |
| break; |
| } |
| } |
| } |
| } |
| #endif |
| |
| } |
| |
| /// <summary> |
| /// An encoded CodeGeneratorRequest is written to the plugin's stdin. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] |
| public sealed partial class CodeGeneratorRequest : pb::IMessage<CodeGeneratorRequest> |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| , pb::IBufferMessage |
| #endif |
| { |
| private static readonly pb::MessageParser<CodeGeneratorRequest> _parser = new pb::MessageParser<CodeGeneratorRequest>(() => new CodeGeneratorRequest()); |
| private pb::UnknownFieldSet _unknownFields; |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public static pb::MessageParser<CodeGeneratorRequest> Parser { get { return _parser; } } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public static pbr::MessageDescriptor Descriptor { |
| get { return global::Google.Protobuf.Compiler.PluginReflection.Descriptor.MessageTypes[1]; } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| pbr::MessageDescriptor pb::IMessage.Descriptor { |
| get { return Descriptor; } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public CodeGeneratorRequest() { |
| OnConstruction(); |
| } |
| |
| partial void OnConstruction(); |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public CodeGeneratorRequest(CodeGeneratorRequest other) : this() { |
| fileToGenerate_ = other.fileToGenerate_.Clone(); |
| parameter_ = other.parameter_; |
| protoFile_ = other.protoFile_.Clone(); |
| sourceFileDescriptors_ = other.sourceFileDescriptors_.Clone(); |
| compilerVersion_ = other.compilerVersion_ != null ? other.compilerVersion_.Clone() : null; |
| _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public CodeGeneratorRequest Clone() { |
| return new CodeGeneratorRequest(this); |
| } |
| |
| /// <summary>Field number for the "file_to_generate" field.</summary> |
| public const int FileToGenerateFieldNumber = 1; |
| private static readonly pb::FieldCodec<string> _repeated_fileToGenerate_codec |
| = pb::FieldCodec.ForString(10); |
| private readonly pbc::RepeatedField<string> fileToGenerate_ = new pbc::RepeatedField<string>(); |
| /// <summary> |
| /// The .proto files that were explicitly listed on the command-line. The |
| /// code generator should generate code only for these files. Each file's |
| /// descriptor will be included in proto_file, below. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public pbc::RepeatedField<string> FileToGenerate { |
| get { return fileToGenerate_; } |
| } |
| |
| /// <summary>Field number for the "parameter" field.</summary> |
| public const int ParameterFieldNumber = 2; |
| private readonly static string ParameterDefaultValue = ""; |
| |
| private string parameter_; |
| /// <summary> |
| /// The generator parameter passed on the command-line. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public string Parameter { |
| get { return parameter_ ?? ParameterDefaultValue; } |
| set { |
| parameter_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); |
| } |
| } |
| /// <summary>Gets whether the "parameter" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasParameter { |
| get { return parameter_ != null; } |
| } |
| /// <summary>Clears the value of the "parameter" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearParameter() { |
| parameter_ = null; |
| } |
| |
| /// <summary>Field number for the "proto_file" field.</summary> |
| public const int ProtoFileFieldNumber = 15; |
| private static readonly pb::FieldCodec<global::Google.Protobuf.Reflection.FileDescriptorProto> _repeated_protoFile_codec |
| = pb::FieldCodec.ForMessage(122, global::Google.Protobuf.Reflection.FileDescriptorProto.Parser); |
| private readonly pbc::RepeatedField<global::Google.Protobuf.Reflection.FileDescriptorProto> protoFile_ = new pbc::RepeatedField<global::Google.Protobuf.Reflection.FileDescriptorProto>(); |
| /// <summary> |
| /// FileDescriptorProtos for all files in files_to_generate and everything |
| /// they import. The files will appear in topological order, so each file |
| /// appears before any file that imports it. |
| /// |
| /// Note: the files listed in files_to_generate will include runtime-retention |
| /// options only, but all other files will include source-retention options. |
| /// The source_file_descriptors field below is available in case you need |
| /// source-retention options for files_to_generate. |
| /// |
| /// protoc guarantees that all proto_files will be written after |
| /// the fields above, even though this is not technically guaranteed by the |
| /// protobuf wire format. This theoretically could allow a plugin to stream |
| /// in the FileDescriptorProtos and handle them one by one rather than read |
| /// the entire set into memory at once. However, as of this writing, this |
| /// is not similarly optimized on protoc's end -- it will store all fields in |
| /// memory at once before sending them to the plugin. |
| /// |
| /// Type names of fields and extensions in the FileDescriptorProto are always |
| /// fully qualified. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public pbc::RepeatedField<global::Google.Protobuf.Reflection.FileDescriptorProto> ProtoFile { |
| get { return protoFile_; } |
| } |
| |
| /// <summary>Field number for the "source_file_descriptors" field.</summary> |
| public const int SourceFileDescriptorsFieldNumber = 17; |
| private static readonly pb::FieldCodec<global::Google.Protobuf.Reflection.FileDescriptorProto> _repeated_sourceFileDescriptors_codec |
| = pb::FieldCodec.ForMessage(138, global::Google.Protobuf.Reflection.FileDescriptorProto.Parser); |
| private readonly pbc::RepeatedField<global::Google.Protobuf.Reflection.FileDescriptorProto> sourceFileDescriptors_ = new pbc::RepeatedField<global::Google.Protobuf.Reflection.FileDescriptorProto>(); |
| /// <summary> |
| /// File descriptors with all options, including source-retention options. |
| /// These descriptors are only provided for the files listed in |
| /// files_to_generate. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public pbc::RepeatedField<global::Google.Protobuf.Reflection.FileDescriptorProto> SourceFileDescriptors { |
| get { return sourceFileDescriptors_; } |
| } |
| |
| /// <summary>Field number for the "compiler_version" field.</summary> |
| public const int CompilerVersionFieldNumber = 3; |
| private global::Google.Protobuf.Compiler.Version compilerVersion_; |
| /// <summary> |
| /// The version number of protocol compiler. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public global::Google.Protobuf.Compiler.Version CompilerVersion { |
| get { return compilerVersion_; } |
| set { |
| compilerVersion_ = value; |
| } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override bool Equals(object other) { |
| return Equals(other as CodeGeneratorRequest); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool Equals(CodeGeneratorRequest other) { |
| if (ReferenceEquals(other, null)) { |
| return false; |
| } |
| if (ReferenceEquals(other, this)) { |
| return true; |
| } |
| if(!fileToGenerate_.Equals(other.fileToGenerate_)) return false; |
| if (Parameter != other.Parameter) return false; |
| if(!protoFile_.Equals(other.protoFile_)) return false; |
| if(!sourceFileDescriptors_.Equals(other.sourceFileDescriptors_)) return false; |
| if (!object.Equals(CompilerVersion, other.CompilerVersion)) return false; |
| return Equals(_unknownFields, other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override int GetHashCode() { |
| int hash = 1; |
| hash ^= fileToGenerate_.GetHashCode(); |
| if (HasParameter) hash ^= Parameter.GetHashCode(); |
| hash ^= protoFile_.GetHashCode(); |
| hash ^= sourceFileDescriptors_.GetHashCode(); |
| if (compilerVersion_ != null) hash ^= CompilerVersion.GetHashCode(); |
| if (_unknownFields != null) { |
| hash ^= _unknownFields.GetHashCode(); |
| } |
| return hash; |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override string ToString() { |
| return pb::JsonFormatter.ToDiagnosticString(this); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void WriteTo(pb::CodedOutputStream output) { |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| output.WriteRawMessage(this); |
| #else |
| fileToGenerate_.WriteTo(output, _repeated_fileToGenerate_codec); |
| if (HasParameter) { |
| output.WriteRawTag(18); |
| output.WriteString(Parameter); |
| } |
| if (compilerVersion_ != null) { |
| output.WriteRawTag(26); |
| output.WriteMessage(CompilerVersion); |
| } |
| protoFile_.WriteTo(output, _repeated_protoFile_codec); |
| sourceFileDescriptors_.WriteTo(output, _repeated_sourceFileDescriptors_codec); |
| if (_unknownFields != null) { |
| _unknownFields.WriteTo(output); |
| } |
| #endif |
| } |
| |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { |
| fileToGenerate_.WriteTo(ref output, _repeated_fileToGenerate_codec); |
| if (HasParameter) { |
| output.WriteRawTag(18); |
| output.WriteString(Parameter); |
| } |
| if (compilerVersion_ != null) { |
| output.WriteRawTag(26); |
| output.WriteMessage(CompilerVersion); |
| } |
| protoFile_.WriteTo(ref output, _repeated_protoFile_codec); |
| sourceFileDescriptors_.WriteTo(ref output, _repeated_sourceFileDescriptors_codec); |
| if (_unknownFields != null) { |
| _unknownFields.WriteTo(ref output); |
| } |
| } |
| #endif |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public int CalculateSize() { |
| int size = 0; |
| size += fileToGenerate_.CalculateSize(_repeated_fileToGenerate_codec); |
| if (HasParameter) { |
| size += 1 + pb::CodedOutputStream.ComputeStringSize(Parameter); |
| } |
| size += protoFile_.CalculateSize(_repeated_protoFile_codec); |
| size += sourceFileDescriptors_.CalculateSize(_repeated_sourceFileDescriptors_codec); |
| if (compilerVersion_ != null) { |
| size += 1 + pb::CodedOutputStream.ComputeMessageSize(CompilerVersion); |
| } |
| if (_unknownFields != null) { |
| size += _unknownFields.CalculateSize(); |
| } |
| return size; |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void MergeFrom(CodeGeneratorRequest other) { |
| if (other == null) { |
| return; |
| } |
| fileToGenerate_.Add(other.fileToGenerate_); |
| if (other.HasParameter) { |
| Parameter = other.Parameter; |
| } |
| protoFile_.Add(other.protoFile_); |
| sourceFileDescriptors_.Add(other.sourceFileDescriptors_); |
| if (other.compilerVersion_ != null) { |
| if (compilerVersion_ == null) { |
| CompilerVersion = new global::Google.Protobuf.Compiler.Version(); |
| } |
| CompilerVersion.MergeFrom(other.CompilerVersion); |
| } |
| _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void MergeFrom(pb::CodedInputStream input) { |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| input.ReadRawMessage(this); |
| #else |
| uint tag; |
| while ((tag = input.ReadTag()) != 0) { |
| if ((tag & 7) == 4) { |
| // Abort on any end group tag. |
| return; |
| } |
| switch(tag) { |
| default: |
| _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); |
| break; |
| case 10: { |
| fileToGenerate_.AddEntriesFrom(input, _repeated_fileToGenerate_codec); |
| break; |
| } |
| case 18: { |
| Parameter = input.ReadString(); |
| break; |
| } |
| case 26: { |
| if (compilerVersion_ == null) { |
| CompilerVersion = new global::Google.Protobuf.Compiler.Version(); |
| } |
| input.ReadMessage(CompilerVersion); |
| break; |
| } |
| case 122: { |
| protoFile_.AddEntriesFrom(input, _repeated_protoFile_codec); |
| break; |
| } |
| case 138: { |
| sourceFileDescriptors_.AddEntriesFrom(input, _repeated_sourceFileDescriptors_codec); |
| break; |
| } |
| } |
| } |
| #endif |
| } |
| |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { |
| uint tag; |
| while ((tag = input.ReadTag()) != 0) { |
| if ((tag & 7) == 4) { |
| // Abort on any end group tag. |
| return; |
| } |
| switch(tag) { |
| default: |
| _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); |
| break; |
| case 10: { |
| fileToGenerate_.AddEntriesFrom(ref input, _repeated_fileToGenerate_codec); |
| break; |
| } |
| case 18: { |
| Parameter = input.ReadString(); |
| break; |
| } |
| case 26: { |
| if (compilerVersion_ == null) { |
| CompilerVersion = new global::Google.Protobuf.Compiler.Version(); |
| } |
| input.ReadMessage(CompilerVersion); |
| break; |
| } |
| case 122: { |
| protoFile_.AddEntriesFrom(ref input, _repeated_protoFile_codec); |
| break; |
| } |
| case 138: { |
| sourceFileDescriptors_.AddEntriesFrom(ref input, _repeated_sourceFileDescriptors_codec); |
| break; |
| } |
| } |
| } |
| } |
| #endif |
| |
| } |
| |
| /// <summary> |
| /// The plugin writes an encoded CodeGeneratorResponse to stdout. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] |
| public sealed partial class CodeGeneratorResponse : pb::IMessage<CodeGeneratorResponse> |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| , pb::IBufferMessage |
| #endif |
| { |
| private static readonly pb::MessageParser<CodeGeneratorResponse> _parser = new pb::MessageParser<CodeGeneratorResponse>(() => new CodeGeneratorResponse()); |
| private pb::UnknownFieldSet _unknownFields; |
| private int _hasBits0; |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public static pb::MessageParser<CodeGeneratorResponse> Parser { get { return _parser; } } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public static pbr::MessageDescriptor Descriptor { |
| get { return global::Google.Protobuf.Compiler.PluginReflection.Descriptor.MessageTypes[2]; } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| pbr::MessageDescriptor pb::IMessage.Descriptor { |
| get { return Descriptor; } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public CodeGeneratorResponse() { |
| OnConstruction(); |
| } |
| |
| partial void OnConstruction(); |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public CodeGeneratorResponse(CodeGeneratorResponse other) : this() { |
| _hasBits0 = other._hasBits0; |
| error_ = other.error_; |
| supportedFeatures_ = other.supportedFeatures_; |
| minimumEdition_ = other.minimumEdition_; |
| maximumEdition_ = other.maximumEdition_; |
| file_ = other.file_.Clone(); |
| _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public CodeGeneratorResponse Clone() { |
| return new CodeGeneratorResponse(this); |
| } |
| |
| /// <summary>Field number for the "error" field.</summary> |
| public const int ErrorFieldNumber = 1; |
| private readonly static string ErrorDefaultValue = ""; |
| |
| private string error_; |
| /// <summary> |
| /// Error message. If non-empty, code generation failed. The plugin process |
| /// should exit with status code zero even if it reports an error in this way. |
| /// |
| /// This should be used to indicate errors in .proto files which prevent the |
| /// code generator from generating correct code. Errors which indicate a |
| /// problem in protoc itself -- such as the input CodeGeneratorRequest being |
| /// unparseable -- should be reported by writing a message to stderr and |
| /// exiting with a non-zero status code. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public string Error { |
| get { return error_ ?? ErrorDefaultValue; } |
| set { |
| error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); |
| } |
| } |
| /// <summary>Gets whether the "error" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasError { |
| get { return error_ != null; } |
| } |
| /// <summary>Clears the value of the "error" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearError() { |
| error_ = null; |
| } |
| |
| /// <summary>Field number for the "supported_features" field.</summary> |
| public const int SupportedFeaturesFieldNumber = 2; |
| private readonly static ulong SupportedFeaturesDefaultValue = 0UL; |
| |
| private ulong supportedFeatures_; |
| /// <summary> |
| /// A bitmask of supported features that the code generator supports. |
| /// This is a bitwise "or" of values from the Feature enum. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public ulong SupportedFeatures { |
| get { if ((_hasBits0 & 1) != 0) { return supportedFeatures_; } else { return SupportedFeaturesDefaultValue; } } |
| set { |
| _hasBits0 |= 1; |
| supportedFeatures_ = value; |
| } |
| } |
| /// <summary>Gets whether the "supported_features" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasSupportedFeatures { |
| get { return (_hasBits0 & 1) != 0; } |
| } |
| /// <summary>Clears the value of the "supported_features" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearSupportedFeatures() { |
| _hasBits0 &= ~1; |
| } |
| |
| /// <summary>Field number for the "minimum_edition" field.</summary> |
| public const int MinimumEditionFieldNumber = 3; |
| private readonly static int MinimumEditionDefaultValue = 0; |
| |
| private int minimumEdition_; |
| /// <summary> |
| /// The minimum edition this plugin supports. This will be treated as an |
| /// Edition enum, but we want to allow unknown values. It should be specified |
| /// according the edition enum value, *not* the edition number. Only takes |
| /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public int MinimumEdition { |
| get { if ((_hasBits0 & 2) != 0) { return minimumEdition_; } else { return MinimumEditionDefaultValue; } } |
| set { |
| _hasBits0 |= 2; |
| minimumEdition_ = value; |
| } |
| } |
| /// <summary>Gets whether the "minimum_edition" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasMinimumEdition { |
| get { return (_hasBits0 & 2) != 0; } |
| } |
| /// <summary>Clears the value of the "minimum_edition" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearMinimumEdition() { |
| _hasBits0 &= ~2; |
| } |
| |
| /// <summary>Field number for the "maximum_edition" field.</summary> |
| public const int MaximumEditionFieldNumber = 4; |
| private readonly static int MaximumEditionDefaultValue = 0; |
| |
| private int maximumEdition_; |
| /// <summary> |
| /// The maximum edition this plugin supports. This will be treated as an |
| /// Edition enum, but we want to allow unknown values. It should be specified |
| /// according the edition enum value, *not* the edition number. Only takes |
| /// effect for plugins that have FEATURE_SUPPORTS_EDITIONS set. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public int MaximumEdition { |
| get { if ((_hasBits0 & 4) != 0) { return maximumEdition_; } else { return MaximumEditionDefaultValue; } } |
| set { |
| _hasBits0 |= 4; |
| maximumEdition_ = value; |
| } |
| } |
| /// <summary>Gets whether the "maximum_edition" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasMaximumEdition { |
| get { return (_hasBits0 & 4) != 0; } |
| } |
| /// <summary>Clears the value of the "maximum_edition" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearMaximumEdition() { |
| _hasBits0 &= ~4; |
| } |
| |
| /// <summary>Field number for the "file" field.</summary> |
| public const int FileFieldNumber = 15; |
| private static readonly pb::FieldCodec<global::Google.Protobuf.Compiler.CodeGeneratorResponse.Types.File> _repeated_file_codec |
| = pb::FieldCodec.ForMessage(122, global::Google.Protobuf.Compiler.CodeGeneratorResponse.Types.File.Parser); |
| private readonly pbc::RepeatedField<global::Google.Protobuf.Compiler.CodeGeneratorResponse.Types.File> file_ = new pbc::RepeatedField<global::Google.Protobuf.Compiler.CodeGeneratorResponse.Types.File>(); |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public pbc::RepeatedField<global::Google.Protobuf.Compiler.CodeGeneratorResponse.Types.File> File { |
| get { return file_; } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override bool Equals(object other) { |
| return Equals(other as CodeGeneratorResponse); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool Equals(CodeGeneratorResponse other) { |
| if (ReferenceEquals(other, null)) { |
| return false; |
| } |
| if (ReferenceEquals(other, this)) { |
| return true; |
| } |
| if (Error != other.Error) return false; |
| if (SupportedFeatures != other.SupportedFeatures) return false; |
| if (MinimumEdition != other.MinimumEdition) return false; |
| if (MaximumEdition != other.MaximumEdition) return false; |
| if(!file_.Equals(other.file_)) return false; |
| return Equals(_unknownFields, other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override int GetHashCode() { |
| int hash = 1; |
| if (HasError) hash ^= Error.GetHashCode(); |
| if (HasSupportedFeatures) hash ^= SupportedFeatures.GetHashCode(); |
| if (HasMinimumEdition) hash ^= MinimumEdition.GetHashCode(); |
| if (HasMaximumEdition) hash ^= MaximumEdition.GetHashCode(); |
| hash ^= file_.GetHashCode(); |
| if (_unknownFields != null) { |
| hash ^= _unknownFields.GetHashCode(); |
| } |
| return hash; |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override string ToString() { |
| return pb::JsonFormatter.ToDiagnosticString(this); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void WriteTo(pb::CodedOutputStream output) { |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| output.WriteRawMessage(this); |
| #else |
| if (HasError) { |
| output.WriteRawTag(10); |
| output.WriteString(Error); |
| } |
| if (HasSupportedFeatures) { |
| output.WriteRawTag(16); |
| output.WriteUInt64(SupportedFeatures); |
| } |
| if (HasMinimumEdition) { |
| output.WriteRawTag(24); |
| output.WriteInt32(MinimumEdition); |
| } |
| if (HasMaximumEdition) { |
| output.WriteRawTag(32); |
| output.WriteInt32(MaximumEdition); |
| } |
| file_.WriteTo(output, _repeated_file_codec); |
| if (_unknownFields != null) { |
| _unknownFields.WriteTo(output); |
| } |
| #endif |
| } |
| |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { |
| if (HasError) { |
| output.WriteRawTag(10); |
| output.WriteString(Error); |
| } |
| if (HasSupportedFeatures) { |
| output.WriteRawTag(16); |
| output.WriteUInt64(SupportedFeatures); |
| } |
| if (HasMinimumEdition) { |
| output.WriteRawTag(24); |
| output.WriteInt32(MinimumEdition); |
| } |
| if (HasMaximumEdition) { |
| output.WriteRawTag(32); |
| output.WriteInt32(MaximumEdition); |
| } |
| file_.WriteTo(ref output, _repeated_file_codec); |
| if (_unknownFields != null) { |
| _unknownFields.WriteTo(ref output); |
| } |
| } |
| #endif |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public int CalculateSize() { |
| int size = 0; |
| if (HasError) { |
| size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); |
| } |
| if (HasSupportedFeatures) { |
| size += 1 + pb::CodedOutputStream.ComputeUInt64Size(SupportedFeatures); |
| } |
| if (HasMinimumEdition) { |
| size += 1 + pb::CodedOutputStream.ComputeInt32Size(MinimumEdition); |
| } |
| if (HasMaximumEdition) { |
| size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaximumEdition); |
| } |
| size += file_.CalculateSize(_repeated_file_codec); |
| if (_unknownFields != null) { |
| size += _unknownFields.CalculateSize(); |
| } |
| return size; |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void MergeFrom(CodeGeneratorResponse other) { |
| if (other == null) { |
| return; |
| } |
| if (other.HasError) { |
| Error = other.Error; |
| } |
| if (other.HasSupportedFeatures) { |
| SupportedFeatures = other.SupportedFeatures; |
| } |
| if (other.HasMinimumEdition) { |
| MinimumEdition = other.MinimumEdition; |
| } |
| if (other.HasMaximumEdition) { |
| MaximumEdition = other.MaximumEdition; |
| } |
| file_.Add(other.file_); |
| _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void MergeFrom(pb::CodedInputStream input) { |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| input.ReadRawMessage(this); |
| #else |
| uint tag; |
| while ((tag = input.ReadTag()) != 0) { |
| if ((tag & 7) == 4) { |
| // Abort on any end group tag. |
| return; |
| } |
| switch(tag) { |
| default: |
| _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); |
| break; |
| case 10: { |
| Error = input.ReadString(); |
| break; |
| } |
| case 16: { |
| SupportedFeatures = input.ReadUInt64(); |
| break; |
| } |
| case 24: { |
| MinimumEdition = input.ReadInt32(); |
| break; |
| } |
| case 32: { |
| MaximumEdition = input.ReadInt32(); |
| break; |
| } |
| case 122: { |
| file_.AddEntriesFrom(input, _repeated_file_codec); |
| break; |
| } |
| } |
| } |
| #endif |
| } |
| |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { |
| uint tag; |
| while ((tag = input.ReadTag()) != 0) { |
| if ((tag & 7) == 4) { |
| // Abort on any end group tag. |
| return; |
| } |
| switch(tag) { |
| default: |
| _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); |
| break; |
| case 10: { |
| Error = input.ReadString(); |
| break; |
| } |
| case 16: { |
| SupportedFeatures = input.ReadUInt64(); |
| break; |
| } |
| case 24: { |
| MinimumEdition = input.ReadInt32(); |
| break; |
| } |
| case 32: { |
| MaximumEdition = input.ReadInt32(); |
| break; |
| } |
| case 122: { |
| file_.AddEntriesFrom(ref input, _repeated_file_codec); |
| break; |
| } |
| } |
| } |
| } |
| #endif |
| |
| #region Nested types |
| /// <summary>Container for nested types declared in the CodeGeneratorResponse message type.</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public static partial class Types { |
| /// <summary> |
| /// Sync with code_generator.h. |
| /// </summary> |
| public enum Feature { |
| [pbr::OriginalName("FEATURE_NONE")] None = 0, |
| [pbr::OriginalName("FEATURE_PROTO3_OPTIONAL")] Proto3Optional = 1, |
| [pbr::OriginalName("FEATURE_SUPPORTS_EDITIONS")] SupportsEditions = 2, |
| } |
| |
| /// <summary> |
| /// Represents a single generated file. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] |
| public sealed partial class File : pb::IMessage<File> |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| , pb::IBufferMessage |
| #endif |
| { |
| private static readonly pb::MessageParser<File> _parser = new pb::MessageParser<File>(() => new File()); |
| private pb::UnknownFieldSet _unknownFields; |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public static pb::MessageParser<File> Parser { get { return _parser; } } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public static pbr::MessageDescriptor Descriptor { |
| get { return global::Google.Protobuf.Compiler.CodeGeneratorResponse.Descriptor.NestedTypes[0]; } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| pbr::MessageDescriptor pb::IMessage.Descriptor { |
| get { return Descriptor; } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public File() { |
| OnConstruction(); |
| } |
| |
| partial void OnConstruction(); |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public File(File other) : this() { |
| name_ = other.name_; |
| insertionPoint_ = other.insertionPoint_; |
| content_ = other.content_; |
| generatedCodeInfo_ = other.generatedCodeInfo_ != null ? other.generatedCodeInfo_.Clone() : null; |
| _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public File Clone() { |
| return new File(this); |
| } |
| |
| /// <summary>Field number for the "name" field.</summary> |
| public const int NameFieldNumber = 1; |
| private readonly static string NameDefaultValue = ""; |
| |
| private string name_; |
| /// <summary> |
| /// The file name, relative to the output directory. The name must not |
| /// contain "." or ".." components and must be relative, not be absolute (so, |
| /// the file cannot lie outside the output directory). "/" must be used as |
| /// the path separator, not "\". |
| /// |
| /// If the name is omitted, the content will be appended to the previous |
| /// file. This allows the generator to break large files into small chunks, |
| /// and allows the generated text to be streamed back to protoc so that large |
| /// files need not reside completely in memory at one time. Note that as of |
| /// this writing protoc does not optimize for this -- it will read the entire |
| /// CodeGeneratorResponse before writing files to disk. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public string Name { |
| get { return name_ ?? NameDefaultValue; } |
| set { |
| name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); |
| } |
| } |
| /// <summary>Gets whether the "name" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasName { |
| get { return name_ != null; } |
| } |
| /// <summary>Clears the value of the "name" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearName() { |
| name_ = null; |
| } |
| |
| /// <summary>Field number for the "insertion_point" field.</summary> |
| public const int InsertionPointFieldNumber = 2; |
| private readonly static string InsertionPointDefaultValue = ""; |
| |
| private string insertionPoint_; |
| /// <summary> |
| /// If non-empty, indicates that the named file should already exist, and the |
| /// content here is to be inserted into that file at a defined insertion |
| /// point. This feature allows a code generator to extend the output |
| /// produced by another code generator. The original generator may provide |
| /// insertion points by placing special annotations in the file that look |
| /// like: |
| /// @@protoc_insertion_point(NAME) |
| /// The annotation can have arbitrary text before and after it on the line, |
| /// which allows it to be placed in a comment. NAME should be replaced with |
| /// an identifier naming the point -- this is what other generators will use |
| /// as the insertion_point. Code inserted at this point will be placed |
| /// immediately above the line containing the insertion point (thus multiple |
| /// insertions to the same point will come out in the order they were added). |
| /// The double-@ is intended to make it unlikely that the generated code |
| /// could contain things that look like insertion points by accident. |
| /// |
| /// For example, the C++ code generator places the following line in the |
| /// .pb.h files that it generates: |
| /// // @@protoc_insertion_point(namespace_scope) |
| /// This line appears within the scope of the file's package namespace, but |
| /// outside of any particular class. Another plugin can then specify the |
| /// insertion_point "namespace_scope" to generate additional classes or |
| /// other declarations that should be placed in this scope. |
| /// |
| /// Note that if the line containing the insertion point begins with |
| /// whitespace, the same whitespace will be added to every line of the |
| /// inserted text. This is useful for languages like Python, where |
| /// indentation matters. In these languages, the insertion point comment |
| /// should be indented the same amount as any inserted code will need to be |
| /// in order to work correctly in that context. |
| /// |
| /// The code generator that generates the initial file and the one which |
| /// inserts into it must both run as part of a single invocation of protoc. |
| /// Code generators are executed in the order in which they appear on the |
| /// command line. |
| /// |
| /// If |insertion_point| is present, |name| must also be present. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public string InsertionPoint { |
| get { return insertionPoint_ ?? InsertionPointDefaultValue; } |
| set { |
| insertionPoint_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); |
| } |
| } |
| /// <summary>Gets whether the "insertion_point" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasInsertionPoint { |
| get { return insertionPoint_ != null; } |
| } |
| /// <summary>Clears the value of the "insertion_point" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearInsertionPoint() { |
| insertionPoint_ = null; |
| } |
| |
| /// <summary>Field number for the "content" field.</summary> |
| public const int ContentFieldNumber = 15; |
| private readonly static string ContentDefaultValue = ""; |
| |
| private string content_; |
| /// <summary> |
| /// The file contents. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public string Content { |
| get { return content_ ?? ContentDefaultValue; } |
| set { |
| content_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); |
| } |
| } |
| /// <summary>Gets whether the "content" field is set</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool HasContent { |
| get { return content_ != null; } |
| } |
| /// <summary>Clears the value of the "content" field</summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void ClearContent() { |
| content_ = null; |
| } |
| |
| /// <summary>Field number for the "generated_code_info" field.</summary> |
| public const int GeneratedCodeInfoFieldNumber = 16; |
| private global::Google.Protobuf.Reflection.GeneratedCodeInfo generatedCodeInfo_; |
| /// <summary> |
| /// Information describing the file content being inserted. If an insertion |
| /// point is used, this information will be appropriately offset and inserted |
| /// into the code generation metadata for the generated files. |
| /// </summary> |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public global::Google.Protobuf.Reflection.GeneratedCodeInfo GeneratedCodeInfo { |
| get { return generatedCodeInfo_; } |
| set { |
| generatedCodeInfo_ = value; |
| } |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override bool Equals(object other) { |
| return Equals(other as File); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public bool Equals(File other) { |
| if (ReferenceEquals(other, null)) { |
| return false; |
| } |
| if (ReferenceEquals(other, this)) { |
| return true; |
| } |
| if (Name != other.Name) return false; |
| if (InsertionPoint != other.InsertionPoint) return false; |
| if (Content != other.Content) return false; |
| if (!object.Equals(GeneratedCodeInfo, other.GeneratedCodeInfo)) return false; |
| return Equals(_unknownFields, other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override int GetHashCode() { |
| int hash = 1; |
| if (HasName) hash ^= Name.GetHashCode(); |
| if (HasInsertionPoint) hash ^= InsertionPoint.GetHashCode(); |
| if (HasContent) hash ^= Content.GetHashCode(); |
| if (generatedCodeInfo_ != null) hash ^= GeneratedCodeInfo.GetHashCode(); |
| if (_unknownFields != null) { |
| hash ^= _unknownFields.GetHashCode(); |
| } |
| return hash; |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public override string ToString() { |
| return pb::JsonFormatter.ToDiagnosticString(this); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void WriteTo(pb::CodedOutputStream output) { |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| output.WriteRawMessage(this); |
| #else |
| if (HasName) { |
| output.WriteRawTag(10); |
| output.WriteString(Name); |
| } |
| if (HasInsertionPoint) { |
| output.WriteRawTag(18); |
| output.WriteString(InsertionPoint); |
| } |
| if (HasContent) { |
| output.WriteRawTag(122); |
| output.WriteString(Content); |
| } |
| if (generatedCodeInfo_ != null) { |
| output.WriteRawTag(130, 1); |
| output.WriteMessage(GeneratedCodeInfo); |
| } |
| if (_unknownFields != null) { |
| _unknownFields.WriteTo(output); |
| } |
| #endif |
| } |
| |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { |
| if (HasName) { |
| output.WriteRawTag(10); |
| output.WriteString(Name); |
| } |
| if (HasInsertionPoint) { |
| output.WriteRawTag(18); |
| output.WriteString(InsertionPoint); |
| } |
| if (HasContent) { |
| output.WriteRawTag(122); |
| output.WriteString(Content); |
| } |
| if (generatedCodeInfo_ != null) { |
| output.WriteRawTag(130, 1); |
| output.WriteMessage(GeneratedCodeInfo); |
| } |
| if (_unknownFields != null) { |
| _unknownFields.WriteTo(ref output); |
| } |
| } |
| #endif |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public int CalculateSize() { |
| int size = 0; |
| if (HasName) { |
| size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); |
| } |
| if (HasInsertionPoint) { |
| size += 1 + pb::CodedOutputStream.ComputeStringSize(InsertionPoint); |
| } |
| if (HasContent) { |
| size += 1 + pb::CodedOutputStream.ComputeStringSize(Content); |
| } |
| if (generatedCodeInfo_ != null) { |
| size += 2 + pb::CodedOutputStream.ComputeMessageSize(GeneratedCodeInfo); |
| } |
| if (_unknownFields != null) { |
| size += _unknownFields.CalculateSize(); |
| } |
| return size; |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void MergeFrom(File other) { |
| if (other == null) { |
| return; |
| } |
| if (other.HasName) { |
| Name = other.Name; |
| } |
| if (other.HasInsertionPoint) { |
| InsertionPoint = other.InsertionPoint; |
| } |
| if (other.HasContent) { |
| Content = other.Content; |
| } |
| if (other.generatedCodeInfo_ != null) { |
| if (generatedCodeInfo_ == null) { |
| GeneratedCodeInfo = new global::Google.Protobuf.Reflection.GeneratedCodeInfo(); |
| } |
| GeneratedCodeInfo.MergeFrom(other.GeneratedCodeInfo); |
| } |
| _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); |
| } |
| |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| public void MergeFrom(pb::CodedInputStream input) { |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| input.ReadRawMessage(this); |
| #else |
| uint tag; |
| while ((tag = input.ReadTag()) != 0) { |
| if ((tag & 7) == 4) { |
| // Abort on any end group tag. |
| return; |
| } |
| switch(tag) { |
| default: |
| _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); |
| break; |
| case 10: { |
| Name = input.ReadString(); |
| break; |
| } |
| case 18: { |
| InsertionPoint = input.ReadString(); |
| break; |
| } |
| case 122: { |
| Content = input.ReadString(); |
| break; |
| } |
| case 130: { |
| if (generatedCodeInfo_ == null) { |
| GeneratedCodeInfo = new global::Google.Protobuf.Reflection.GeneratedCodeInfo(); |
| } |
| input.ReadMessage(GeneratedCodeInfo); |
| break; |
| } |
| } |
| } |
| #endif |
| } |
| |
| #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE |
| [global::System.Diagnostics.DebuggerNonUserCodeAttribute] |
| [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] |
| void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { |
| uint tag; |
| while ((tag = input.ReadTag()) != 0) { |
| if ((tag & 7) == 4) { |
| // Abort on any end group tag. |
| return; |
| } |
| switch(tag) { |
| default: |
| _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); |
| break; |
| case 10: { |
| Name = input.ReadString(); |
| break; |
| } |
| case 18: { |
| InsertionPoint = input.ReadString(); |
| break; |
| } |
| case 122: { |
| Content = input.ReadString(); |
| break; |
| } |
| case 130: { |
| if (generatedCodeInfo_ == null) { |
| GeneratedCodeInfo = new global::Google.Protobuf.Reflection.GeneratedCodeInfo(); |
| } |
| input.ReadMessage(GeneratedCodeInfo); |
| break; |
| } |
| } |
| } |
| } |
| #endif |
| |
| } |
| |
| } |
| #endregion |
| |
| } |
| |
| #endregion |
| |
| } |
| |
| #endregion Designer generated code |
