path: root/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs

// Generated by the protocol buffer compiler.  DO NOT EDIT!

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.DescriptorProtos {
  
  public static partial class CSharpOptions {
  
    #region Extension registration
    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
      registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFileOptions);
      registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFieldOptions);
    }
    #endregion
    #region Extensions
    public const int CSharpFileOptionsFieldNumber = 1000;
    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions> CSharpFileOptions;
    public const int CSharpFieldOptionsFieldNumber = 1000;
    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions> CSharpFieldOptions;
    #endregion
    
    #region Static variables
    internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpFileOptions__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Builder> internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpFieldOptions__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Builder> internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable;
    #endregion
    #region Descriptor
    public static pbd::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbd::FileDescriptor descriptor;
    
    static CSharpOptions() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          "CiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8SD2dvb2ds" + 
          "ZS5wcm90b2J1ZhogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG8i" + 
          "iAEKEUNTaGFycEZpbGVPcHRpb25zEhEKCW5hbWVzcGFjZRgBIAEoCRIaChJ1" + 
          "bWJyZWxsYV9jbGFzc25hbWUYAiABKAkSFgoOcHVibGljX2NsYXNzZXMYAyAB" + 
          "KAgSFgoObXVsdGlwbGVfZmlsZXMYBCABKAgSFAoMbmVzdF9jbGFzc2VzGAUg" + 
          "ASgIIisKEkNTaGFycEZpZWxkT3B0aW9ucxIVCg1wcm9wZXJ0eV9uYW1lGAEg" + 
          "ASgJOl4KE2NzaGFycF9maWxlX29wdGlvbnMSHC5nb29nbGUucHJvdG9idWYu" + 
          "RmlsZU9wdGlvbnMY6AcgASgLMiIuZ29vZ2xlLnByb3RvYnVmLkNTaGFycEZp" + 
          "bGVPcHRpb25zOmEKFGNzaGFycF9maWVsZF9vcHRpb25zEh0uZ29vZ2xlLnBy" + 
          "b3RvYnVmLkZpZWxkT3B0aW9ucxjoByABKAsyIy5nb29nbGUucHJvdG9idWYu" + 
          "Q1NoYXJwRmllbGRPcHRpb25z");
      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
        descriptor = root;
        internal__static_google_protobuf_CSharpFileOptions__Descriptor = Descriptor.MessageTypes[0];
        internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Builder>(internal__static_google_protobuf_CSharpFileOptions__Descriptor,
                new string[] { "Namespace", "UmbrellaClassname", "PublicClasses", "MultipleFiles", "NestClasses", });
        internal__static_google_protobuf_CSharpFieldOptions__Descriptor = Descriptor.MessageTypes[1];
        internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Builder>(internal__static_google_protobuf_CSharpFieldOptions__Descriptor,
                new string[] { "PropertyName", });
        global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFileOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[0]);
        global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CSharpFieldOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[1]);
        return null;
      };
      pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
          new pbd::FileDescriptor[] {
          global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, 
          }, assigner);
    }
    #endregion
    
  }
  #region Messages
  public sealed partial class CSharpFileOptions : pb::GeneratedMessage<CSharpFileOptions, CSharpFileOptions.Builder> {
    private static readonly CSharpFileOptions defaultInstance = new Builder().BuildPartial();
    public static CSharpFileOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override CSharpFileOptions DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override CSharpFileOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFileOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<CSharpFileOptions, CSharpFileOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFileOptions__FieldAccessorTable; }
    }
    
    public const int NamespaceFieldNumber = 1;
    private bool hasNamespace;
    private string namespace_ = "";
    public bool HasNamespace {
      get { return hasNamespace; }
    }
    public string Namespace {
      get { return namespace_; }
    }
    
    public const int UmbrellaClassnameFieldNumber = 2;
    private bool hasUmbrellaClassname;
    private string umbrellaClassname_ = "";
    public bool HasUmbrellaClassname {
      get { return hasUmbrellaClassname; }
    }
    public string UmbrellaClassname {
      get { return umbrellaClassname_; }
    }
    
    public const int PublicClassesFieldNumber = 3;
    private bool hasPublicClasses;
    private bool publicClasses_ = false;
    public bool HasPublicClasses {
      get { return hasPublicClasses; }
    }
    public bool PublicClasses {
      get { return publicClasses_; }
    }
    
    public const int MultipleFilesFieldNumber = 4;
    private bool hasMultipleFiles;
    private bool multipleFiles_ = false;
    public bool HasMultipleFiles {
      get { return hasMultipleFiles; }
    }
    public bool MultipleFiles {
      get { return multipleFiles_; }
    }
    
    public const int NestClassesFieldNumber = 5;
    private bool hasNestClasses;
    private bool nestClasses_ = false;
    public bool HasNestClasses {
      get { return hasNestClasses; }
    }
    public bool NestClasses {
      get { return nestClasses_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasNamespace) {
        output.WriteString(1, Namespace);
      }
      if (HasUmbrellaClassname) {
        output.WriteString(2, UmbrellaClassname);
      }
      if (HasPublicClasses) {
        output.WriteBool(3, PublicClasses);
      }
      if (HasMultipleFiles) {
        output.WriteBool(4, MultipleFiles);
      }
      if (HasNestClasses) {
        output.WriteBool(5, NestClasses);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasNamespace) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Namespace);
        }
        if (HasUmbrellaClassname) {
          size += pb::CodedOutputStream.ComputeStringSize(2, UmbrellaClassname);
        }
        if (HasPublicClasses) {
          size += pb::CodedOutputStream.ComputeBoolSize(3, PublicClasses);
        }
        if (HasMultipleFiles) {
          size += pb::CodedOutputStream.ComputeBoolSize(4, MultipleFiles);
        }
        if (HasNestClasses) {
          size += pb::CodedOutputStream.ComputeBoolSize(5, NestClasses);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static CSharpFileOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static CSharpFileOptions ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static CSharpFileOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpFileOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(CSharpFileOptions prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<CSharpFileOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {}
      
      CSharpFileOptions result = new CSharpFileOptions();
      
      protected override CSharpFileOptions MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new CSharpFileOptions();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return CSharpFileOptions.Descriptor; }
      }
      
      public override CSharpFileOptions DefaultInstanceForType {
        get { return CSharpFileOptions.DefaultInstance; }
      }
      
      public override CSharpFileOptions BuildPartial() {
        if (result == null) {
          throw new global::System.InvalidOperationException("build() has already been called on this Builder");
        }
        CSharpFileOptions returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is CSharpFileOptions) {
          return MergeFrom((CSharpFileOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(CSharpFileOptions other) {
        if (other == CSharpFileOptions.DefaultInstance) return this;
        if (other.HasNamespace) {
          Namespace = other.Namespace;
        }
        if (other.HasUmbrellaClassname) {
          UmbrellaClassname = other.UmbrellaClassname;
        }
        if (other.HasPublicClasses) {
          PublicClasses = other.PublicClasses;
        }
        if (other.HasMultipleFiles) {
          MultipleFiles = other.MultipleFiles;
        }
        if (other.HasNestClasses) {
          NestClasses = other.NestClasses;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields = null;
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0: {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag);
              break;
            }
            case 10: {
              Namespace = input.ReadString();
              break;
            }
            case 18: {
              UmbrellaClassname = input.ReadString();
              break;
            }
            case 24: {
              PublicClasses = input.ReadBool();
              break;
            }
            case 32: {
              MultipleFiles = input.ReadBool();
              break;
            }
            case 40: {
              NestClasses = input.ReadBool();
              break;
            }
          }
        }
      }
      
      
      public bool HasNamespace {
        get { return result.HasNamespace; }
      }
      public string Namespace {
        get { return result.Namespace; }
        set { SetNamespace(value); }
      }
      public Builder SetNamespace(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasNamespace = true;
        result.namespace_ = value;
        return this;
      }
      public Builder ClearNamespace() {
        result.hasNamespace = false;
        result.namespace_ = "";
        return this;
      }
      
      public bool HasUmbrellaClassname {
        get { return result.HasUmbrellaClassname; }
      }
      public string UmbrellaClassname {
        get { return result.UmbrellaClassname; }
        set { SetUmbrellaClassname(value); }
      }
      public Builder SetUmbrellaClassname(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasUmbrellaClassname = true;
        result.umbrellaClassname_ = value;
        return this;
      }
      public Builder ClearUmbrellaClassname() {
        result.hasUmbrellaClassname = false;
        result.umbrellaClassname_ = "";
        return this;
      }
      
      public bool HasPublicClasses {
        get { return result.HasPublicClasses; }
      }
      public bool PublicClasses {
        get { return result.PublicClasses; }
        set { SetPublicClasses(value); }
      }
      public Builder SetPublicClasses(bool value) {
        result.hasPublicClasses = true;
        result.publicClasses_ = value;
        return this;
      }
      public Builder ClearPublicClasses() {
        result.hasPublicClasses = false;
        result.publicClasses_ = false;
        return this;
      }
      
      public bool HasMultipleFiles {
        get { return result.HasMultipleFiles; }
      }
      public bool MultipleFiles {
        get { return result.MultipleFiles; }
        set { SetMultipleFiles(value); }
      }
      public Builder SetMultipleFiles(bool value) {
        result.hasMultipleFiles = true;
        result.multipleFiles_ = value;
        return this;
      }
      public Builder ClearMultipleFiles() {
        result.hasMultipleFiles = false;
        result.multipleFiles_ = false;
        return this;
      }
      
      public bool HasNestClasses {
        get { return result.HasNestClasses; }
      }
      public bool NestClasses {
        get { return result.NestClasses; }
        set { SetNestClasses(value); }
      }
      public Builder SetNestClasses(bool value) {
        result.hasNestClasses = true;
        result.nestClasses_ = value;
        return this;
      }
      public Builder ClearNestClasses() {
        result.hasNestClasses = false;
        result.nestClasses_ = false;
        return this;
      }
    }
    static CSharpFileOptions() {
      pbd::FileDescriptor descriptor = global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor;
    }
  }
  
  public sealed partial class CSharpFieldOptions : pb::GeneratedMessage<CSharpFieldOptions, CSharpFieldOptions.Builder> {
    private static readonly CSharpFieldOptions defaultInstance = new Builder().BuildPartial();
    public static CSharpFieldOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override CSharpFieldOptions DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override CSharpFieldOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFieldOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<CSharpFieldOptions, CSharpFieldOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpFieldOptions__FieldAccessorTable; }
    }
    
    public const int PropertyNameFieldNumber = 1;
    private bool hasPropertyName;
    private string propertyName_ = "";
    public bool HasPropertyName {
      get { return hasPropertyName; }
    }
    public string PropertyName {
      get { return propertyName_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasPropertyName) {
        output.WriteString(1, PropertyName);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasPropertyName) {
          size += pb::CodedOutputStream.ComputeStringSize(1, PropertyName);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static CSharpFieldOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static CSharpFieldOptions ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static CSharpFieldOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static CSharpFieldOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder ToBuilder() { return CreateBuilder(this); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(CSharpFieldOptions prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<CSharpFieldOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {}
      
      CSharpFieldOptions result = new CSharpFieldOptions();
      
      protected override CSharpFieldOptions MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new CSharpFieldOptions();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return CSharpFieldOptions.Descriptor; }
      }
      
      public override CSharpFieldOptions DefaultInstanceForType {
        get { return CSharpFieldOptions.DefaultInstance; }
      }
      
      public override CSharpFieldOptions BuildPartial() {
        if (result == null) {
          throw new global::System.InvalidOperationException("build() has already been called on this Builder");
        }
        CSharpFieldOptions returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is CSharpFieldOptions) {
          return MergeFrom((CSharpFieldOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(CSharpFieldOptions other) {
        if (other == CSharpFieldOptions.DefaultInstance) return this;
        if (other.HasPropertyName) {
          PropertyName = other.PropertyName;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields = null;
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0: {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag);
              break;
            }
            case 10: {
              PropertyName = input.ReadString();
              break;
            }
          }
        }
      }
      
      
      public bool HasPropertyName {
        get { return result.HasPropertyName; }
      }
      public string PropertyName {
        get { return result.PropertyName; }
        set { SetPropertyName(value); }
      }
      public Builder SetPropertyName(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasPropertyName = true;
        result.propertyName_ = value;
        return this;
      }
      public Builder ClearPropertyName() {
        result.hasPropertyName = false;
        result.propertyName_ = "";
        return this;
      }
    }
    static CSharpFieldOptions() {
      pbd::FileDescriptor descriptor = global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor;
    }
  }
  
  #endregion
  
}