Skip to content

P
protobuf
Commit f3504cf3 authored by Jon Skeet's avatar Jon Skeet
Browse files
Options

First part of making the C# runtime work with the new codegen. 

1) Remove CSharpOptions
2) A new version of DescriptorProtoFile (with manual changes from codegen - it would otherwise be Descriptor.cs)
3) Turn off CLS compliance (which we'll remove from the codebase entirely; I don't think it's actually relevant these days)
4) Add "public imports" to FileDescriptor, with code broadly copied from the Java codebase.
Lots more changes to commit before it will build and tests run, but one step at a time...
parent b977c3ed
Hide whitespace changes
Inline Side-by-side
Showing with 101 additions and 2283 deletions
csharp/src/ProtocolBuffers.Test/CSharpOptionsTest.cs deleted 100644 → 0
View file @ b977c3ed
#region Copyright notice and license
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code:
// http://code.google.com/p/protobuf/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion
using Google.ProtocolBuffers.DescriptorProtos;
using Google.ProtocolBuffers.Descriptors;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace Google.ProtocolBuffers
{
[TestClass]
public class DescriptorUtilTest
{
[TestMethod]
public void ExplicitNamespace()
{
FileDescriptorProto proto = new FileDescriptorProto.Builder
{
Name = "x",
Package = "pack",
Options =
new FileOptions.Builder().SetExtension(
CSharpOptions.CSharpFileOptions,
new CSharpFileOptions.Builder {Namespace = "Foo.Bar"}.Build()).
Build()
}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("Foo.Bar", descriptor.CSharpOptions.Namespace);
}
[TestMethod]
public void NoNamespaceFallsBackToPackage()
{
FileDescriptorProto proto = new FileDescriptorProto.Builder {Name = "x", Package = "pack"}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("pack", descriptor.CSharpOptions.Namespace);
}
[TestMethod]
public void NoNamespaceOrPackageFallsBackToEmptyString()
{
FileDescriptorProto proto = new FileDescriptorProto.Builder {Name = "x"}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("", descriptor.CSharpOptions.Namespace);
}
[TestMethod]
public void ExplicitlyNamedFileClass()
{
FileDescriptorProto proto = new FileDescriptorProto.Builder
{
Name = "x",
Options =
new FileOptions.Builder().SetExtension(
CSharpOptions.CSharpFileOptions,
new CSharpFileOptions.Builder {UmbrellaClassname = "Foo"}.Build())
.Build()
}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("Foo", descriptor.CSharpOptions.UmbrellaClassname);
}
[TestMethod]
public void ImplicitFileClassWithProtoSuffix()
{
FileDescriptorProto proto = new FileDescriptorProto.Builder {Name = "foo_bar.proto"}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("FooBar", descriptor.CSharpOptions.UmbrellaClassname);
}
[TestMethod]
public void ImplicitFileClassWithProtoDevelSuffix()
{
FileDescriptorProto proto = new FileDescriptorProto.Builder {Name = "foo_bar.protodevel"}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("FooBar", descriptor.CSharpOptions.UmbrellaClassname);
}
[TestMethod]
public void ImplicitFileClassWithNoSuffix()
{
FileDescriptorProto proto = new FileDescriptorProto.Builder {Name = "foo_bar"}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("FooBar", descriptor.CSharpOptions.UmbrellaClassname);
}
[TestMethod]
public void ImplicitFileClassWithDirectoryStructure()
{
FileDescriptorProto proto = new FileDescriptorProto.Builder {Name = "x/y/foo_bar"}.Build();
FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null);
Assert.AreEqual("FooBar", descriptor.CSharpOptions.UmbrellaClassname);
}
}
}
\ No newline at end of file
csharp/src/ProtocolBuffers.Test/Descriptors/MessageDescriptorTest.cs deleted 100644 → 0
View file @ b977c3ed
#region Copyright notice and license
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code:
// http://code.google.com/p/protobuf/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Google.ProtocolBuffers.TestProtos;
namespace Google.ProtocolBuffers.Descriptors
{
[TestClass]
public class MessageDescriptorTest
{
[TestMethod]
public void FindPropertyWithDefaultName()
{
Assert.AreSame(OptionsMessage.Descriptor.FindFieldByNumber(OptionsMessage.NormalFieldNumber),
OptionsMessage.Descriptor.FindFieldByPropertyName("Normal"));
}
[TestMethod]
public void FindPropertyWithAutoModifiedName()
{
Assert.AreSame(OptionsMessage.Descriptor.FindFieldByNumber(OptionsMessage.OptionsMessage_FieldNumber),
OptionsMessage.Descriptor.FindFieldByPropertyName("OptionsMessage_"));
}
[TestMethod]
public void FindPropertyWithCustomizedName()
{
Assert.AreSame(OptionsMessage.Descriptor.FindFieldByNumber(OptionsMessage.CustomNameFieldNumber),
OptionsMessage.Descriptor.FindFieldByPropertyName("CustomName"));
}
[TestMethod]
public void FindPropertyWithInvalidName()
{
Assert.IsNull(OptionsMessage.Descriptor.FindFieldByPropertyName("Bogus"));
}
}
}
\ No newline at end of file
csharp/src/ProtocolBuffers.Test/Properties/AssemblyInfo.cs
View file @ f3504cf3
......@@ -32,4 +32,4 @@ using System.Runtime.InteropServices;
// We don't really need CLSCompliance, but if the assembly builds with no warnings,
// that means the generator is okay.
[assembly: CLSCompliant(true)]
\ No newline at end of file
[assembly: CLSCompliant(false)]
\ No newline at end of file
csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
View file @ f3504cf3
......@@ -86,10 +86,8 @@
<Compile Include="TestResources.cs" />
<Compile Include="TestRpcForMimeTypes.cs" />
<Compile Include="TestReaderForUrlEncoded.cs" />
<Compile Include="CSharpOptionsTest.cs" />
<Compile Include="DeprecatedMemberTest.cs" />
<Compile Include="DescriptorsTest.cs" />
<Compile Include="Descriptors\MessageDescriptorTest.cs" />
<Compile Include="DynamicMessageTest.cs" />
<Compile Include="ExtendableMessageTest.cs" />
<Compile Include="GeneratedBuilderTest.cs" />
......
csharp/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs deleted 100644 → 0
View file @ b977c3ed
// Generated by ProtoGen, Version=2.4.1.555, Culture=neutral, PublicKeyToken=55f7125234beb589. DO NOT EDIT!
#pragma warning disable 1591, 0612, 3021
#region Designer generated code
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 {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
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);
registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpServiceOptions);
registry.Add(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpMethodOptions);
}
#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;
public const int CsharpServiceOptionsFieldNumber = 1000;
public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions> CsharpServiceOptions;
public const int CsharpMethodOptionsFieldNumber = 1000;
public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions> CsharpMethodOptions;
#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;
internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpServiceOptions__Descriptor;
internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.Builder> internal__static_google_protobuf_CSharpServiceOptions__FieldAccessorTable;
internal static pbd::MessageDescriptor internal__static_google_protobuf_CSharpMethodOptions__Descriptor;
internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.Builder> internal__static_google_protobuf_CSharpMethodOptions__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(
string.Concat(
"CiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8SD2dvb2ds",
"ZS5wcm90b2J1ZhogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG8i",
"pwQKEUNTaGFycEZpbGVPcHRpb25zEhEKCW5hbWVzcGFjZRgBIAEoCRIaChJ1",
"bWJyZWxsYV9jbGFzc25hbWUYAiABKAkSHAoOcHVibGljX2NsYXNzZXMYAyAB",
"KAg6BHRydWUSFgoObXVsdGlwbGVfZmlsZXMYBCABKAgSFAoMbmVzdF9jbGFz",
"c2VzGAUgASgIEhYKDmNvZGVfY29udHJhY3RzGAYgASgIEiQKHGV4cGFuZF9u",
"YW1lc3BhY2VfZGlyZWN0b3JpZXMYByABKAgSHAoOY2xzX2NvbXBsaWFuY2UY",
"CCABKAg6BHRydWUSHwoQYWRkX3NlcmlhbGl6YWJsZRgJIAEoCDoFZmFsc2US",
"IwoVZ2VuZXJhdGVfcHJpdmF0ZV9jdG9yGAogASgIOgR0cnVlEhwKDmZpbGVf",
"ZXh0ZW5zaW9uGN0BIAEoCToDLmNzEhsKEnVtYnJlbGxhX25hbWVzcGFjZRje",
"ASABKAkSHAoQb3V0cHV0X2RpcmVjdG9yeRjfASABKAk6AS4SJgoWaWdub3Jl",
"X2dvb2dsZV9wcm90b2J1ZhjgASABKAg6BWZhbHNlEkkKFnNlcnZpY2VfZ2Vu",
"ZXJhdG9yX3R5cGUY4QEgASgOMiIuZ29vZ2xlLnByb3RvYnVmLkNTaGFycFNl",
"cnZpY2VUeXBlOgROT05FEikKGWdlbmVyYXRlZF9jb2RlX2F0dHJpYnV0ZXMY",
"4gEgASgIOgVmYWxzZSIrChJDU2hhcnBGaWVsZE9wdGlvbnMSFQoNcHJvcGVy",
"dHlfbmFtZRgBIAEoCSIsChRDU2hhcnBTZXJ2aWNlT3B0aW9ucxIUCgxpbnRl",
"cmZhY2VfaWQYASABKAkiKgoTQ1NoYXJwTWV0aG9kT3B0aW9ucxITCgtkaXNw",
"YXRjaF9pZBgBIAEoBSpLChFDU2hhcnBTZXJ2aWNlVHlwZRIICgROT05FEAAS",
"CwoHR0VORVJJQxABEg0KCUlOVEVSRkFDRRACEhAKDElSUENESVNQQVRDSBAD",
"Ol4KE2NzaGFycF9maWxlX29wdGlvbnMSHC5nb29nbGUucHJvdG9idWYuRmls",
"ZU9wdGlvbnMY6AcgASgLMiIuZ29vZ2xlLnByb3RvYnVmLkNTaGFycEZpbGVP",
"cHRpb25zOmEKFGNzaGFycF9maWVsZF9vcHRpb25zEh0uZ29vZ2xlLnByb3Rv",
"YnVmLkZpZWxkT3B0aW9ucxjoByABKAsyIy5nb29nbGUucHJvdG9idWYuQ1No",
"YXJwRmllbGRPcHRpb25zOmcKFmNzaGFycF9zZXJ2aWNlX29wdGlvbnMSHy5n",
"b29nbGUucHJvdG9idWYuU2VydmljZU9wdGlvbnMY6AcgASgLMiUuZ29vZ2xl",
"LnByb3RvYnVmLkNTaGFycFNlcnZpY2VPcHRpb25zOmQKFWNzaGFycF9tZXRo",
"b2Rfb3B0aW9ucxIeLmdvb2dsZS5wcm90b2J1Zi5NZXRob2RPcHRpb25zGOgH",
"IAEoCzIkLmdvb2dsZS5wcm90b2J1Zi5DU2hhcnBNZXRob2RPcHRpb25z"));
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", "CodeContracts", "ExpandNamespaceDirectories", "ClsCompliance", "AddSerializable", "GeneratePrivateCtor", "FileExtension", "UmbrellaNamespace", "OutputDirectory", "IgnoreGoogleProtobuf", "ServiceGeneratorType", "GeneratedCodeAttributes", });
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", });
internal__static_google_protobuf_CSharpServiceOptions__Descriptor = Descriptor.MessageTypes[2];
internal__static_google_protobuf_CSharpServiceOptions__FieldAccessorTable =
new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.Builder>(internal__static_google_protobuf_CSharpServiceOptions__Descriptor,
new string[] { "InterfaceId", });
internal__static_google_protobuf_CSharpMethodOptions__Descriptor = Descriptor.MessageTypes[3];
internal__static_google_protobuf_CSharpMethodOptions__FieldAccessorTable =
new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.Builder>(internal__static_google_protobuf_CSharpMethodOptions__Descriptor,
new string[] { "DispatchId", });
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]);
global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpServiceOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[2]);
global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.CsharpMethodOptions = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions>.CreateInstance(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor.Extensions[3]);
return null;
};
pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
new pbd::FileDescriptor[] {
global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor,
}, assigner);
}
#endregion
}
#region Enums
public enum CSharpServiceType {
NONE = 0,
GENERIC = 1,
INTERFACE = 2,
IRPCDISPATCH = 3,
}
#endregion
#region Messages
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class CSharpFileOptions : pb::GeneratedMessage<CSharpFileOptions, CSharpFileOptions.Builder> {
private CSharpFileOptions() { }
private static readonly CSharpFileOptions defaultInstance = new CSharpFileOptions().MakeReadOnly();
private static readonly string[] _cSharpFileOptionsFieldNames = new string[] { "add_serializable", "cls_compliance", "code_contracts", "expand_namespace_directories", "file_extension", "generate_private_ctor", "generated_code_attributes", "ignore_google_protobuf", "multiple_files", "namespace", "nest_classes", "output_directory", "public_classes", "service_generator_type", "umbrella_classname", "umbrella_namespace" };
private static readonly uint[] _cSharpFileOptionsFieldTags = new uint[] { 72, 64, 48, 56, 1770, 80, 1808, 1792, 32, 10, 40, 1786, 24, 1800, 18, 1778 };
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_ = true;
public bool HasPublicClasses {
get { return hasPublicClasses; }
}
public bool PublicClasses {
get { return publicClasses_; }
}
public const int MultipleFilesFieldNumber = 4;
private bool hasMultipleFiles;
private bool multipleFiles_;
public bool HasMultipleFiles {
get { return hasMultipleFiles; }
}
public bool MultipleFiles {
get { return multipleFiles_; }
}
public const int NestClassesFieldNumber = 5;
private bool hasNestClasses;
private bool nestClasses_;
public bool HasNestClasses {
get { return hasNestClasses; }
}
public bool NestClasses {
get { return nestClasses_; }
}
public const int CodeContractsFieldNumber = 6;
private bool hasCodeContracts;
private bool codeContracts_;
public bool HasCodeContracts {
get { return hasCodeContracts; }
}
public bool CodeContracts {
get { return codeContracts_; }
}
public const int ExpandNamespaceDirectoriesFieldNumber = 7;
private bool hasExpandNamespaceDirectories;
private bool expandNamespaceDirectories_;
public bool HasExpandNamespaceDirectories {
get { return hasExpandNamespaceDirectories; }
}
public bool ExpandNamespaceDirectories {
get { return expandNamespaceDirectories_; }
}
public const int ClsComplianceFieldNumber = 8;
private bool hasClsCompliance;
private bool clsCompliance_ = true;
public bool HasClsCompliance {
get { return hasClsCompliance; }
}
public bool ClsCompliance {
get { return clsCompliance_; }
}
public const int AddSerializableFieldNumber = 9;
private bool hasAddSerializable;
private bool addSerializable_;
public bool HasAddSerializable {
get { return hasAddSerializable; }
}
public bool AddSerializable {
get { return addSerializable_; }
}
public const int GeneratePrivateCtorFieldNumber = 10;
private bool hasGeneratePrivateCtor;
private bool generatePrivateCtor_ = true;
public bool HasGeneratePrivateCtor {
get { return hasGeneratePrivateCtor; }
}
public bool GeneratePrivateCtor {
get { return generatePrivateCtor_; }
}
public const int FileExtensionFieldNumber = 221;
private bool hasFileExtension;
private string fileExtension_ = ".cs";
public bool HasFileExtension {
get { return hasFileExtension; }
}
public string FileExtension {
get { return fileExtension_; }
}
public const int UmbrellaNamespaceFieldNumber = 222;
private bool hasUmbrellaNamespace;
private string umbrellaNamespace_ = "";
public bool HasUmbrellaNamespace {
get { return hasUmbrellaNamespace; }
}
public string UmbrellaNamespace {
get { return umbrellaNamespace_; }
}
public const int OutputDirectoryFieldNumber = 223;
private bool hasOutputDirectory;
private string outputDirectory_ = ".";
public bool HasOutputDirectory {
get { return hasOutputDirectory; }
}
public string OutputDirectory {
get { return outputDirectory_; }
}
public const int IgnoreGoogleProtobufFieldNumber = 224;
private bool hasIgnoreGoogleProtobuf;
private bool ignoreGoogleProtobuf_;
public bool HasIgnoreGoogleProtobuf {
get { return hasIgnoreGoogleProtobuf; }
}
public bool IgnoreGoogleProtobuf {
get { return ignoreGoogleProtobuf_; }
}
public const int ServiceGeneratorTypeFieldNumber = 225;
private bool hasServiceGeneratorType;
private global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType serviceGeneratorType_ = global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType.NONE;
public bool HasServiceGeneratorType {
get { return hasServiceGeneratorType; }
}
public global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType ServiceGeneratorType {
get { return serviceGeneratorType_; }
}
public const int GeneratedCodeAttributesFieldNumber = 226;
private bool hasGeneratedCodeAttributes;
private bool generatedCodeAttributes_;
public bool HasGeneratedCodeAttributes {
get { return hasGeneratedCodeAttributes; }
}
public bool GeneratedCodeAttributes {
get { return generatedCodeAttributes_; }
}
public override bool IsInitialized {
get {
return true;
}
}
public override void WriteTo(pb::ICodedOutputStream output) {
CalcSerializedSize();
string[] field_names = _cSharpFileOptionsFieldNames;
if (hasNamespace) {
output.WriteString(1, field_names[9], Namespace);
}
if (hasUmbrellaClassname) {
output.WriteString(2, field_names[14], UmbrellaClassname);
}
if (hasPublicClasses) {
output.WriteBool(3, field_names[12], PublicClasses);
}
if (hasMultipleFiles) {
output.WriteBool(4, field_names[8], MultipleFiles);
}
if (hasNestClasses) {
output.WriteBool(5, field_names[10], NestClasses);
}
if (hasCodeContracts) {
output.WriteBool(6, field_names[2], CodeContracts);
}
if (hasExpandNamespaceDirectories) {
output.WriteBool(7, field_names[3], ExpandNamespaceDirectories);
}
if (hasClsCompliance) {
output.WriteBool(8, field_names[1], ClsCompliance);
}
if (hasAddSerializable) {
output.WriteBool(9, field_names[0], AddSerializable);
}
if (hasGeneratePrivateCtor) {
output.WriteBool(10, field_names[5], GeneratePrivateCtor);
}
if (hasFileExtension) {
output.WriteString(221, field_names[4], FileExtension);
}
if (hasUmbrellaNamespace) {
output.WriteString(222, field_names[15], UmbrellaNamespace);
}
if (hasOutputDirectory) {
output.WriteString(223, field_names[11], OutputDirectory);
}
if (hasIgnoreGoogleProtobuf) {
output.WriteBool(224, field_names[7], IgnoreGoogleProtobuf);
}
if (hasServiceGeneratorType) {
output.WriteEnum(225, field_names[13], (int) ServiceGeneratorType, ServiceGeneratorType);
}
if (hasGeneratedCodeAttributes) {
output.WriteBool(226, field_names[6], GeneratedCodeAttributes);
}
UnknownFields.WriteTo(output);
}
private int memoizedSerializedSize = -1;
public override int SerializedSize {
get {
int size = memoizedSerializedSize;
if (size != -1) return size;
return CalcSerializedSize();
}
}
private int CalcSerializedSize() {
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);
}
if (hasCodeContracts) {
size += pb::CodedOutputStream.ComputeBoolSize(6, CodeContracts);
}
if (hasExpandNamespaceDirectories) {
size += pb::CodedOutputStream.ComputeBoolSize(7, ExpandNamespaceDirectories);
}
if (hasClsCompliance) {
size += pb::CodedOutputStream.ComputeBoolSize(8, ClsCompliance);
}
if (hasAddSerializable) {
size += pb::CodedOutputStream.ComputeBoolSize(9, AddSerializable);
}
if (hasGeneratePrivateCtor) {
size += pb::CodedOutputStream.ComputeBoolSize(10, GeneratePrivateCtor);
}
if (hasFileExtension) {
size += pb::CodedOutputStream.ComputeStringSize(221, FileExtension);
}
if (hasUmbrellaNamespace) {
size += pb::CodedOutputStream.ComputeStringSize(222, UmbrellaNamespace);
}
if (hasOutputDirectory) {
size += pb::CodedOutputStream.ComputeStringSize(223, OutputDirectory);
}
if (hasIgnoreGoogleProtobuf) {
size += pb::CodedOutputStream.ComputeBoolSize(224, IgnoreGoogleProtobuf);
}
if (hasServiceGeneratorType) {
size += pb::CodedOutputStream.ComputeEnumSize(225, (int) ServiceGeneratorType);
}
if (hasGeneratedCodeAttributes) {
size += pb::CodedOutputStream.ComputeBoolSize(226, GeneratedCodeAttributes);
}
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::ICodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static CSharpFileOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
}
private CSharpFileOptions MakeReadOnly() {
return this;
}
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 new Builder(prototype);
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class Builder : pb::GeneratedBuilder<CSharpFileOptions, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
public Builder() {
result = DefaultInstance;
resultIsReadOnly = true;
}
internal Builder(CSharpFileOptions cloneFrom) {
result = cloneFrom;
resultIsReadOnly = true;
}
private bool resultIsReadOnly;
private CSharpFileOptions result;
private CSharpFileOptions PrepareBuilder() {
if (resultIsReadOnly) {
CSharpFileOptions original = result;
result = new CSharpFileOptions();
resultIsReadOnly = false;
MergeFrom(original);
}
return result;
}
public override bool IsInitialized {
get { return result.IsInitialized; }
}
protected override CSharpFileOptions MessageBeingBuilt {
get { return PrepareBuilder(); }
}
public override Builder Clear() {
result = DefaultInstance;
resultIsReadOnly = true;
return this;
}
public override Builder Clone() {
if (resultIsReadOnly) {
return new Builder(result);
} else {
return new Builder().MergeFrom(result);
}
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.Descriptor; }
}
public override CSharpFileOptions DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.DefaultInstance; }
}
public override CSharpFileOptions BuildPartial() {
if (resultIsReadOnly) {
return result;
}
resultIsReadOnly = true;
return result.MakeReadOnly();
}
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 == global::Google.ProtocolBuffers.DescriptorProtos.CSharpFileOptions.DefaultInstance) return this;
PrepareBuilder();
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;
}
if (other.HasCodeContracts) {
CodeContracts = other.CodeContracts;
}
if (other.HasExpandNamespaceDirectories) {
ExpandNamespaceDirectories = other.ExpandNamespaceDirectories;
}
if (other.HasClsCompliance) {
ClsCompliance = other.ClsCompliance;
}
if (other.HasAddSerializable) {
AddSerializable = other.AddSerializable;
}
if (other.HasGeneratePrivateCtor) {
GeneratePrivateCtor = other.GeneratePrivateCtor;
}
if (other.HasFileExtension) {
FileExtension = other.FileExtension;
}
if (other.HasUmbrellaNamespace) {
UmbrellaNamespace = other.UmbrellaNamespace;
}
if (other.HasOutputDirectory) {
OutputDirectory = other.OutputDirectory;
}
if (other.HasIgnoreGoogleProtobuf) {
IgnoreGoogleProtobuf = other.IgnoreGoogleProtobuf;
}
if (other.HasServiceGeneratorType) {
ServiceGeneratorType = other.ServiceGeneratorType;
}
if (other.HasGeneratedCodeAttributes) {
GeneratedCodeAttributes = other.GeneratedCodeAttributes;
}
this.MergeUnknownFields(other.UnknownFields);
return this;
}
public override Builder MergeFrom(pb::ICodedInputStream input) {
return MergeFrom(input, pb::ExtensionRegistry.Empty);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name)) {
if(tag == 0 && field_name != null) {
int field_ordinal = global::System.Array.BinarySearch(_cSharpFileOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
if(field_ordinal >= 0)
tag = _cSharpFileOptionsFieldTags[field_ordinal];
else {
if (unknownFields == null) {
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag) {
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
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, field_name);
break;
}
case 10: {
result.hasNamespace = input.ReadString(ref result.namespace_);
break;
}
case 18: {
result.hasUmbrellaClassname = input.ReadString(ref result.umbrellaClassname_);
break;
}
case 24: {
result.hasPublicClasses = input.ReadBool(ref result.publicClasses_);
break;
}
case 32: {
result.hasMultipleFiles = input.ReadBool(ref result.multipleFiles_);
break;
}
case 40: {
result.hasNestClasses = input.ReadBool(ref result.nestClasses_);
break;
}
case 48: {
result.hasCodeContracts = input.ReadBool(ref result.codeContracts_);
break;
}
case 56: {
result.hasExpandNamespaceDirectories = input.ReadBool(ref result.expandNamespaceDirectories_);
break;
}
case 64: {
result.hasClsCompliance = input.ReadBool(ref result.clsCompliance_);
break;
}
case 72: {
result.hasAddSerializable = input.ReadBool(ref result.addSerializable_);
break;
}
case 80: {
result.hasGeneratePrivateCtor = input.ReadBool(ref result.generatePrivateCtor_);
break;
}
case 1770: {
result.hasFileExtension = input.ReadString(ref result.fileExtension_);
break;
}
case 1778: {
result.hasUmbrellaNamespace = input.ReadString(ref result.umbrellaNamespace_);
break;
}
case 1786: {
result.hasOutputDirectory = input.ReadString(ref result.outputDirectory_);
break;
}
case 1792: {
result.hasIgnoreGoogleProtobuf = input.ReadBool(ref result.ignoreGoogleProtobuf_);
break;
}
case 1800: {
object unknown;
if(input.ReadEnum(ref result.serviceGeneratorType_, out unknown)) {
result.hasServiceGeneratorType = true;
} else if(unknown is int) {
if (unknownFields == null) {
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
unknownFields.MergeVarintField(225, (ulong)(int)unknown);
}
break;
}
case 1808: {
result.hasGeneratedCodeAttributes = input.ReadBool(ref result.generatedCodeAttributes_);
break;
}
}
}
if (unknownFields != null) {
this.UnknownFields = unknownFields.Build();
}
return this;
}
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");
PrepareBuilder();
result.hasNamespace = true;
result.namespace_ = value;
return this;
}
public Builder ClearNamespace() {
PrepareBuilder();
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");
PrepareBuilder();
result.hasUmbrellaClassname = true;
result.umbrellaClassname_ = value;
return this;
}
public Builder ClearUmbrellaClassname() {
PrepareBuilder();
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) {
PrepareBuilder();
result.hasPublicClasses = true;
result.publicClasses_ = value;
return this;
}
public Builder ClearPublicClasses() {
PrepareBuilder();
result.hasPublicClasses = false;
result.publicClasses_ = true;
return this;
}
public bool HasMultipleFiles {
get { return result.hasMultipleFiles; }
}
public bool MultipleFiles {
get { return result.MultipleFiles; }
set { SetMultipleFiles(value); }
}
public Builder SetMultipleFiles(bool value) {
PrepareBuilder();
result.hasMultipleFiles = true;
result.multipleFiles_ = value;
return this;
}
public Builder ClearMultipleFiles() {
PrepareBuilder();
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) {
PrepareBuilder();
result.hasNestClasses = true;
result.nestClasses_ = value;
return this;
}
public Builder ClearNestClasses() {
PrepareBuilder();
result.hasNestClasses = false;
result.nestClasses_ = false;
return this;
}
public bool HasCodeContracts {
get { return result.hasCodeContracts; }
}
public bool CodeContracts {
get { return result.CodeContracts; }
set { SetCodeContracts(value); }
}
public Builder SetCodeContracts(bool value) {
PrepareBuilder();
result.hasCodeContracts = true;
result.codeContracts_ = value;
return this;
}
public Builder ClearCodeContracts() {
PrepareBuilder();
result.hasCodeContracts = false;
result.codeContracts_ = false;
return this;
}
public bool HasExpandNamespaceDirectories {
get { return result.hasExpandNamespaceDirectories; }
}
public bool ExpandNamespaceDirectories {
get { return result.ExpandNamespaceDirectories; }
set { SetExpandNamespaceDirectories(value); }
}
public Builder SetExpandNamespaceDirectories(bool value) {
PrepareBuilder();
result.hasExpandNamespaceDirectories = true;
result.expandNamespaceDirectories_ = value;
return this;
}
public Builder ClearExpandNamespaceDirectories() {
PrepareBuilder();
result.hasExpandNamespaceDirectories = false;
result.expandNamespaceDirectories_ = false;
return this;
}
public bool HasClsCompliance {
get { return result.hasClsCompliance; }
}
public bool ClsCompliance {
get { return result.ClsCompliance; }
set { SetClsCompliance(value); }
}
public Builder SetClsCompliance(bool value) {
PrepareBuilder();
result.hasClsCompliance = true;
result.clsCompliance_ = value;
return this;
}
public Builder ClearClsCompliance() {
PrepareBuilder();
result.hasClsCompliance = false;
result.clsCompliance_ = true;
return this;
}
public bool HasAddSerializable {
get { return result.hasAddSerializable; }
}
public bool AddSerializable {
get { return result.AddSerializable; }
set { SetAddSerializable(value); }
}
public Builder SetAddSerializable(bool value) {
PrepareBuilder();
result.hasAddSerializable = true;
result.addSerializable_ = value;
return this;
}
public Builder ClearAddSerializable() {
PrepareBuilder();
result.hasAddSerializable = false;
result.addSerializable_ = false;
return this;
}
public bool HasGeneratePrivateCtor {
get { return result.hasGeneratePrivateCtor; }
}
public bool GeneratePrivateCtor {
get { return result.GeneratePrivateCtor; }
set { SetGeneratePrivateCtor(value); }
}
public Builder SetGeneratePrivateCtor(bool value) {
PrepareBuilder();
result.hasGeneratePrivateCtor = true;
result.generatePrivateCtor_ = value;
return this;
}
public Builder ClearGeneratePrivateCtor() {
PrepareBuilder();
result.hasGeneratePrivateCtor = false;
result.generatePrivateCtor_ = true;
return this;
}
public bool HasFileExtension {
get { return result.hasFileExtension; }
}
public string FileExtension {
get { return result.FileExtension; }
set { SetFileExtension(value); }
}
public Builder SetFileExtension(string value) {
pb::ThrowHelper.ThrowIfNull(value, "value");
PrepareBuilder();
result.hasFileExtension = true;
result.fileExtension_ = value;
return this;
}
public Builder ClearFileExtension() {
PrepareBuilder();
result.hasFileExtension = false;
result.fileExtension_ = ".cs";
return this;
}
public bool HasUmbrellaNamespace {
get { return result.hasUmbrellaNamespace; }
}
public string UmbrellaNamespace {
get { return result.UmbrellaNamespace; }
set { SetUmbrellaNamespace(value); }
}
public Builder SetUmbrellaNamespace(string value) {
pb::ThrowHelper.ThrowIfNull(value, "value");
PrepareBuilder();
result.hasUmbrellaNamespace = true;
result.umbrellaNamespace_ = value;
return this;
}
public Builder ClearUmbrellaNamespace() {
PrepareBuilder();
result.hasUmbrellaNamespace = false;
result.umbrellaNamespace_ = "";
return this;
}
public bool HasOutputDirectory {
get { return result.hasOutputDirectory; }
}
public string OutputDirectory {
get { return result.OutputDirectory; }
set { SetOutputDirectory(value); }
}
public Builder SetOutputDirectory(string value) {
pb::ThrowHelper.ThrowIfNull(value, "value");
PrepareBuilder();
result.hasOutputDirectory = true;
result.outputDirectory_ = value;
return this;
}
public Builder ClearOutputDirectory() {
PrepareBuilder();
result.hasOutputDirectory = false;
result.outputDirectory_ = ".";
return this;
}
public bool HasIgnoreGoogleProtobuf {
get { return result.hasIgnoreGoogleProtobuf; }
}
public bool IgnoreGoogleProtobuf {
get { return result.IgnoreGoogleProtobuf; }
set { SetIgnoreGoogleProtobuf(value); }
}
public Builder SetIgnoreGoogleProtobuf(bool value) {
PrepareBuilder();
result.hasIgnoreGoogleProtobuf = true;
result.ignoreGoogleProtobuf_ = value;
return this;
}
public Builder ClearIgnoreGoogleProtobuf() {
PrepareBuilder();
result.hasIgnoreGoogleProtobuf = false;
result.ignoreGoogleProtobuf_ = false;
return this;
}
public bool HasServiceGeneratorType {
get { return result.hasServiceGeneratorType; }
}
public global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType ServiceGeneratorType {
get { return result.ServiceGeneratorType; }
set { SetServiceGeneratorType(value); }
}
public Builder SetServiceGeneratorType(global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType value) {
PrepareBuilder();
result.hasServiceGeneratorType = true;
result.serviceGeneratorType_ = value;
return this;
}
public Builder ClearServiceGeneratorType() {
PrepareBuilder();
result.hasServiceGeneratorType = false;
result.serviceGeneratorType_ = global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceType.NONE;
return this;
}
public bool HasGeneratedCodeAttributes {
get { return result.hasGeneratedCodeAttributes; }
}
public bool GeneratedCodeAttributes {
get { return result.GeneratedCodeAttributes; }
set { SetGeneratedCodeAttributes(value); }
}
public Builder SetGeneratedCodeAttributes(bool value) {
PrepareBuilder();
result.hasGeneratedCodeAttributes = true;
result.generatedCodeAttributes_ = value;
return this;
}
public Builder ClearGeneratedCodeAttributes() {
PrepareBuilder();
result.hasGeneratedCodeAttributes = false;
result.generatedCodeAttributes_ = false;
return this;
}
}
static CSharpFileOptions() {
object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
}
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class CSharpFieldOptions : pb::GeneratedMessage<CSharpFieldOptions, CSharpFieldOptions.Builder> {
private CSharpFieldOptions() { }
private static readonly CSharpFieldOptions defaultInstance = new CSharpFieldOptions().MakeReadOnly();
private static readonly string[] _cSharpFieldOptionsFieldNames = new string[] { "property_name" };
private static readonly uint[] _cSharpFieldOptionsFieldTags = new uint[] { 10 };
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::ICodedOutputStream output) {
CalcSerializedSize();
string[] field_names = _cSharpFieldOptionsFieldNames;
if (hasPropertyName) {
output.WriteString(1, field_names[0], PropertyName);
}
UnknownFields.WriteTo(output);
}
private int memoizedSerializedSize = -1;
public override int SerializedSize {
get {
int size = memoizedSerializedSize;
if (size != -1) return size;
return CalcSerializedSize();
}
}
private int CalcSerializedSize() {
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::ICodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static CSharpFieldOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
}
private CSharpFieldOptions MakeReadOnly() {
return this;
}
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 new Builder(prototype);
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class Builder : pb::GeneratedBuilder<CSharpFieldOptions, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
public Builder() {
result = DefaultInstance;
resultIsReadOnly = true;
}
internal Builder(CSharpFieldOptions cloneFrom) {
result = cloneFrom;
resultIsReadOnly = true;
}
private bool resultIsReadOnly;
private CSharpFieldOptions result;
private CSharpFieldOptions PrepareBuilder() {
if (resultIsReadOnly) {
CSharpFieldOptions original = result;
result = new CSharpFieldOptions();
resultIsReadOnly = false;
MergeFrom(original);
}
return result;
}
public override bool IsInitialized {
get { return result.IsInitialized; }
}
protected override CSharpFieldOptions MessageBeingBuilt {
get { return PrepareBuilder(); }
}
public override Builder Clear() {
result = DefaultInstance;
resultIsReadOnly = true;
return this;
}
public override Builder Clone() {
if (resultIsReadOnly) {
return new Builder(result);
} else {
return new Builder().MergeFrom(result);
}
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.Descriptor; }
}
public override CSharpFieldOptions DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.DefaultInstance; }
}
public override CSharpFieldOptions BuildPartial() {
if (resultIsReadOnly) {
return result;
}
resultIsReadOnly = true;
return result.MakeReadOnly();
}
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 == global::Google.ProtocolBuffers.DescriptorProtos.CSharpFieldOptions.DefaultInstance) return this;
PrepareBuilder();
if (other.HasPropertyName) {
PropertyName = other.PropertyName;
}
this.MergeUnknownFields(other.UnknownFields);
return this;
}
public override Builder MergeFrom(pb::ICodedInputStream input) {
return MergeFrom(input, pb::ExtensionRegistry.Empty);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name)) {
if(tag == 0 && field_name != null) {
int field_ordinal = global::System.Array.BinarySearch(_cSharpFieldOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
if(field_ordinal >= 0)
tag = _cSharpFieldOptionsFieldTags[field_ordinal];
else {
if (unknownFields == null) {
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag) {
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
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, field_name);
break;
}
case 10: {
result.hasPropertyName = input.ReadString(ref result.propertyName_);
break;
}
}
}
if (unknownFields != null) {
this.UnknownFields = unknownFields.Build();
}
return this;
}
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");
PrepareBuilder();
result.hasPropertyName = true;
result.propertyName_ = value;
return this;
}
public Builder ClearPropertyName() {
PrepareBuilder();
result.hasPropertyName = false;
result.propertyName_ = "";
return this;
}
}
static CSharpFieldOptions() {
object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
}
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class CSharpServiceOptions : pb::GeneratedMessage<CSharpServiceOptions, CSharpServiceOptions.Builder> {
private CSharpServiceOptions() { }
private static readonly CSharpServiceOptions defaultInstance = new CSharpServiceOptions().MakeReadOnly();
private static readonly string[] _cSharpServiceOptionsFieldNames = new string[] { "interface_id" };
private static readonly uint[] _cSharpServiceOptionsFieldTags = new uint[] { 10 };
public static CSharpServiceOptions DefaultInstance {
get { return defaultInstance; }
}
public override CSharpServiceOptions DefaultInstanceForType {
get { return DefaultInstance; }
}
protected override CSharpServiceOptions ThisMessage {
get { return this; }
}
public static pbd::MessageDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpServiceOptions__Descriptor; }
}
protected override pb::FieldAccess.FieldAccessorTable<CSharpServiceOptions, CSharpServiceOptions.Builder> InternalFieldAccessors {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpServiceOptions__FieldAccessorTable; }
}
public const int InterfaceIdFieldNumber = 1;
private bool hasInterfaceId;
private string interfaceId_ = "";
public bool HasInterfaceId {
get { return hasInterfaceId; }
}
public string InterfaceId {
get { return interfaceId_; }
}
public override bool IsInitialized {
get {
return true;
}
}
public override void WriteTo(pb::ICodedOutputStream output) {
CalcSerializedSize();
string[] field_names = _cSharpServiceOptionsFieldNames;
if (hasInterfaceId) {
output.WriteString(1, field_names[0], InterfaceId);
}
UnknownFields.WriteTo(output);
}
private int memoizedSerializedSize = -1;
public override int SerializedSize {
get {
int size = memoizedSerializedSize;
if (size != -1) return size;
return CalcSerializedSize();
}
}
private int CalcSerializedSize() {
int size = memoizedSerializedSize;
if (size != -1) return size;
size = 0;
if (hasInterfaceId) {
size += pb::CodedOutputStream.ComputeStringSize(1, InterfaceId);
}
size += UnknownFields.SerializedSize;
memoizedSerializedSize = size;
return size;
}
public static CSharpServiceOptions ParseFrom(pb::ByteString data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static CSharpServiceOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
}
public static CSharpServiceOptions ParseFrom(byte[] data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static CSharpServiceOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
}
public static CSharpServiceOptions ParseFrom(global::System.IO.Stream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static CSharpServiceOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
}
public static CSharpServiceOptions ParseDelimitedFrom(global::System.IO.Stream input) {
return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
}
public static CSharpServiceOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
}
public static CSharpServiceOptions ParseFrom(pb::ICodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static CSharpServiceOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
}
private CSharpServiceOptions MakeReadOnly() {
return this;
}
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(CSharpServiceOptions prototype) {
return new Builder(prototype);
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class Builder : pb::GeneratedBuilder<CSharpServiceOptions, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
public Builder() {
result = DefaultInstance;
resultIsReadOnly = true;
}
internal Builder(CSharpServiceOptions cloneFrom) {
result = cloneFrom;
resultIsReadOnly = true;
}
private bool resultIsReadOnly;
private CSharpServiceOptions result;
private CSharpServiceOptions PrepareBuilder() {
if (resultIsReadOnly) {
CSharpServiceOptions original = result;
result = new CSharpServiceOptions();
resultIsReadOnly = false;
MergeFrom(original);
}
return result;
}
public override bool IsInitialized {
get { return result.IsInitialized; }
}
protected override CSharpServiceOptions MessageBeingBuilt {
get { return PrepareBuilder(); }
}
public override Builder Clear() {
result = DefaultInstance;
resultIsReadOnly = true;
return this;
}
public override Builder Clone() {
if (resultIsReadOnly) {
return new Builder(result);
} else {
return new Builder().MergeFrom(result);
}
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.Descriptor; }
}
public override CSharpServiceOptions DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.DefaultInstance; }
}
public override CSharpServiceOptions BuildPartial() {
if (resultIsReadOnly) {
return result;
}
resultIsReadOnly = true;
return result.MakeReadOnly();
}
public override Builder MergeFrom(pb::IMessage other) {
if (other is CSharpServiceOptions) {
return MergeFrom((CSharpServiceOptions) other);
} else {
base.MergeFrom(other);
return this;
}
}
public override Builder MergeFrom(CSharpServiceOptions other) {
if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpServiceOptions.DefaultInstance) return this;
PrepareBuilder();
if (other.HasInterfaceId) {
InterfaceId = other.InterfaceId;
}
this.MergeUnknownFields(other.UnknownFields);
return this;
}
public override Builder MergeFrom(pb::ICodedInputStream input) {
return MergeFrom(input, pb::ExtensionRegistry.Empty);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name)) {
if(tag == 0 && field_name != null) {
int field_ordinal = global::System.Array.BinarySearch(_cSharpServiceOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
if(field_ordinal >= 0)
tag = _cSharpServiceOptionsFieldTags[field_ordinal];
else {
if (unknownFields == null) {
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag) {
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
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, field_name);
break;
}
case 10: {
result.hasInterfaceId = input.ReadString(ref result.interfaceId_);
break;
}
}
}
if (unknownFields != null) {
this.UnknownFields = unknownFields.Build();
}
return this;
}
public bool HasInterfaceId {
get { return result.hasInterfaceId; }
}
public string InterfaceId {
get { return result.InterfaceId; }
set { SetInterfaceId(value); }
}
public Builder SetInterfaceId(string value) {
pb::ThrowHelper.ThrowIfNull(value, "value");
PrepareBuilder();
result.hasInterfaceId = true;
result.interfaceId_ = value;
return this;
}
public Builder ClearInterfaceId() {
PrepareBuilder();
result.hasInterfaceId = false;
result.interfaceId_ = "";
return this;
}
}
static CSharpServiceOptions() {
object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
}
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class CSharpMethodOptions : pb::GeneratedMessage<CSharpMethodOptions, CSharpMethodOptions.Builder> {
private CSharpMethodOptions() { }
private static readonly CSharpMethodOptions defaultInstance = new CSharpMethodOptions().MakeReadOnly();
private static readonly string[] _cSharpMethodOptionsFieldNames = new string[] { "dispatch_id" };
private static readonly uint[] _cSharpMethodOptionsFieldTags = new uint[] { 8 };
public static CSharpMethodOptions DefaultInstance {
get { return defaultInstance; }
}
public override CSharpMethodOptions DefaultInstanceForType {
get { return DefaultInstance; }
}
protected override CSharpMethodOptions ThisMessage {
get { return this; }
}
public static pbd::MessageDescriptor Descriptor {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpMethodOptions__Descriptor; }
}
protected override pb::FieldAccess.FieldAccessorTable<CSharpMethodOptions, CSharpMethodOptions.Builder> InternalFieldAccessors {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.internal__static_google_protobuf_CSharpMethodOptions__FieldAccessorTable; }
}
public const int DispatchIdFieldNumber = 1;
private bool hasDispatchId;
private int dispatchId_;
public bool HasDispatchId {
get { return hasDispatchId; }
}
public int DispatchId {
get { return dispatchId_; }
}
public override bool IsInitialized {
get {
return true;
}
}
public override void WriteTo(pb::ICodedOutputStream output) {
CalcSerializedSize();
string[] field_names = _cSharpMethodOptionsFieldNames;
if (hasDispatchId) {
output.WriteInt32(1, field_names[0], DispatchId);
}
UnknownFields.WriteTo(output);
}
private int memoizedSerializedSize = -1;
public override int SerializedSize {
get {
int size = memoizedSerializedSize;
if (size != -1) return size;
return CalcSerializedSize();
}
}
private int CalcSerializedSize() {
int size = memoizedSerializedSize;
if (size != -1) return size;
size = 0;
if (hasDispatchId) {
size += pb::CodedOutputStream.ComputeInt32Size(1, DispatchId);
}
size += UnknownFields.SerializedSize;
memoizedSerializedSize = size;
return size;
}
public static CSharpMethodOptions ParseFrom(pb::ByteString data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static CSharpMethodOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
}
public static CSharpMethodOptions ParseFrom(byte[] data) {
return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
}
public static CSharpMethodOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
}
public static CSharpMethodOptions ParseFrom(global::System.IO.Stream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static CSharpMethodOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
}
public static CSharpMethodOptions ParseDelimitedFrom(global::System.IO.Stream input) {
return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
}
public static CSharpMethodOptions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
}
public static CSharpMethodOptions ParseFrom(pb::ICodedInputStream input) {
return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
}
public static CSharpMethodOptions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
}
private CSharpMethodOptions MakeReadOnly() {
return this;
}
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(CSharpMethodOptions prototype) {
return new Builder(prototype);
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
public sealed partial class Builder : pb::GeneratedBuilder<CSharpMethodOptions, Builder> {
protected override Builder ThisBuilder {
get { return this; }
}
public Builder() {
result = DefaultInstance;
resultIsReadOnly = true;
}
internal Builder(CSharpMethodOptions cloneFrom) {
result = cloneFrom;
resultIsReadOnly = true;
}
private bool resultIsReadOnly;
private CSharpMethodOptions result;
private CSharpMethodOptions PrepareBuilder() {
if (resultIsReadOnly) {
CSharpMethodOptions original = result;
result = new CSharpMethodOptions();
resultIsReadOnly = false;
MergeFrom(original);
}
return result;
}
public override bool IsInitialized {
get { return result.IsInitialized; }
}
protected override CSharpMethodOptions MessageBeingBuilt {
get { return PrepareBuilder(); }
}
public override Builder Clear() {
result = DefaultInstance;
resultIsReadOnly = true;
return this;
}
public override Builder Clone() {
if (resultIsReadOnly) {
return new Builder(result);
} else {
return new Builder().MergeFrom(result);
}
}
public override pbd::MessageDescriptor DescriptorForType {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.Descriptor; }
}
public override CSharpMethodOptions DefaultInstanceForType {
get { return global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.DefaultInstance; }
}
public override CSharpMethodOptions BuildPartial() {
if (resultIsReadOnly) {
return result;
}
resultIsReadOnly = true;
return result.MakeReadOnly();
}
public override Builder MergeFrom(pb::IMessage other) {
if (other is CSharpMethodOptions) {
return MergeFrom((CSharpMethodOptions) other);
} else {
base.MergeFrom(other);
return this;
}
}
public override Builder MergeFrom(CSharpMethodOptions other) {
if (other == global::Google.ProtocolBuffers.DescriptorProtos.CSharpMethodOptions.DefaultInstance) return this;
PrepareBuilder();
if (other.HasDispatchId) {
DispatchId = other.DispatchId;
}
this.MergeUnknownFields(other.UnknownFields);
return this;
}
public override Builder MergeFrom(pb::ICodedInputStream input) {
return MergeFrom(input, pb::ExtensionRegistry.Empty);
}
public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
PrepareBuilder();
pb::UnknownFieldSet.Builder unknownFields = null;
uint tag;
string field_name;
while (input.ReadTag(out tag, out field_name)) {
if(tag == 0 && field_name != null) {
int field_ordinal = global::System.Array.BinarySearch(_cSharpMethodOptionsFieldNames, field_name, global::System.StringComparer.Ordinal);
if(field_ordinal >= 0)
tag = _cSharpMethodOptionsFieldTags[field_ordinal];
else {
if (unknownFields == null) {
unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
}
ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
continue;
}
}
switch (tag) {
case 0: {
throw pb::InvalidProtocolBufferException.InvalidTag();
}
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, field_name);
break;
}
case 8: {
result.hasDispatchId = input.ReadInt32(ref result.dispatchId_);
break;
}
}
}
if (unknownFields != null) {
this.UnknownFields = unknownFields.Build();
}
return this;
}
public bool HasDispatchId {
get { return result.hasDispatchId; }
}
public int DispatchId {
get { return result.DispatchId; }
set { SetDispatchId(value); }
}
public Builder SetDispatchId(int value) {
PrepareBuilder();
result.hasDispatchId = true;
result.dispatchId_ = value;
return this;
}
public Builder ClearDispatchId() {
PrepareBuilder();
result.hasDispatchId = false;
result.dispatchId_ = 0;
return this;
}
}
static CSharpMethodOptions() {
object.ReferenceEquals(global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, null);
}
}
#endregion
}
#endregion Designer generated code
csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
View file @ f3504cf3
This source diff could not be displayed because it is too large. You can view the blob instead.
csharp/src/ProtocolBuffers/Descriptors/DescriptorPool.cs
View file @ f3504cf3
......@@ -50,14 +50,15 @@ namespace Google.ProtocolBuffers.Descriptors
private readonly IDictionary<DescriptorIntPair, EnumValueDescriptor> enumValuesByNumber =
new Dictionary<DescriptorIntPair, EnumValueDescriptor>();
private readonly DescriptorPool[] dependencies;
private readonly HashSet<FileDescriptor> dependencies;
internal DescriptorPool(FileDescriptor[] dependencyFiles)
{
dependencies = new DescriptorPool[dependencyFiles.Length];
dependencies = new HashSet<FileDescriptor>();
for (int i = 0; i < dependencyFiles.Length; i++)
{
dependencies[i] = dependencyFiles[i].DescriptorPool;
dependencies.Add(dependencyFiles[i]);
ImportPublicDependencies(dependencyFiles[i]);
}
foreach (FileDescriptor dependency in dependencyFiles)
......@@ -66,6 +67,17 @@ namespace Google.ProtocolBuffers.Descriptors
}
}
private void ImportPublicDependencies(FileDescriptor file)
{
foreach (FileDescriptor dependency in file.PublicDependencies)
{
if (dependencies.Add(dependency))
{
ImportPublicDependencies(dependency);
}
}
}
/// <summary>
/// Finds a symbol of the given name within the pool.
/// </summary>
......@@ -83,9 +95,9 @@ namespace Google.ProtocolBuffers.Descriptors
return descriptor;
}
foreach (DescriptorPool dependency in dependencies)
foreach (FileDescriptor dependency in dependencies)
{
dependency.descriptorsByName.TryGetValue(fullName, out result);
dependency.DescriptorPool.descriptorsByName.TryGetValue(fullName, out result);
descriptor = result as T;
if (descriptor != null)
{
......
csharp/src/ProtocolBuffers/Descriptors/FieldDescriptor.cs
View file @ f3504cf3
......@@ -51,7 +51,6 @@ namespace Google.ProtocolBuffers.Descriptors
private FieldType fieldType;
private MappedType mappedType;
private CSharpFieldOptions csharpFieldOptions;
private readonly object optionsLock = new object();
internal FieldDescriptor(FieldDescriptorProto proto, FileDescriptor file,
......@@ -101,38 +100,6 @@ namespace Google.ProtocolBuffers.Descriptors
file.DescriptorPool.AddSymbol(this);
}
private CSharpFieldOptions BuildOrFakeCSharpOptions()
{
// TODO(jonskeet): Check if we could use FileDescriptorProto.Descriptor.Name - interesting bootstrap issues
if (File.Proto.Name == "google/protobuf/csharp_options.proto")
{
if (Name == "csharp_field_options")
{
return new CSharpFieldOptions.Builder {PropertyName = "CSharpFieldOptions"}.Build();
}
if (Name == "csharp_file_options")
{
return new CSharpFieldOptions.Builder {PropertyName = "CSharpFileOptions"}.Build();
}
}
CSharpFieldOptions.Builder builder = CSharpFieldOptions.CreateBuilder();
if (Proto.Options.HasExtension(DescriptorProtos.CSharpOptions.CSharpFieldOptions))
{
builder.MergeFrom(Proto.Options.GetExtension(DescriptorProtos.CSharpOptions.CSharpFieldOptions));
}
if (!builder.HasPropertyName)
{
string fieldName = FieldType == FieldType.Group ? MessageType.Name : Name;
string propertyName = NameHelpers.UnderscoresToPascalCase(fieldName);
if (propertyName == ContainingType.Name)
{
propertyName += "_";
}
builder.PropertyName = propertyName;
}
return builder.Build();
}
/// <summary>
/// Maps a field type as included in the .proto file to a FieldType.
/// </summary>
......@@ -286,26 +253,7 @@ namespace Google.ProtocolBuffers.Descriptors
{
get { return containingType; }
}
/// <summary>
/// Returns the C#-specific options for this field descriptor. This will always be
/// completely filled in.
/// </summary>
public CSharpFieldOptions CSharpOptions
{
get
{
lock (optionsLock)
{
if (csharpFieldOptions == null)
{
csharpFieldOptions = BuildOrFakeCSharpOptions();
}
}
return csharpFieldOptions;
}
}
/// <summary>
/// For extensions defined nested within message types, gets
/// the outer type. Not valid for non-extension fields.
......
csharp/src/ProtocolBuffers/Descriptors/FileDescriptor.cs
View file @ f3504cf3
......@@ -51,16 +51,17 @@ namespace Google.ProtocolBuffers.Descriptors
private readonly IList<ServiceDescriptor> services;
private readonly IList<FieldDescriptor> extensions;
private readonly IList<FileDescriptor> dependencies;
private readonly IList<FileDescriptor> publicDependencies;
private readonly DescriptorPool pool;
private CSharpFileOptions csharpFileOptions;
private readonly object optionsLock = new object();
private FileDescriptor(FileDescriptorProto proto, FileDescriptor[] dependencies, DescriptorPool pool)
private FileDescriptor(FileDescriptorProto proto, FileDescriptor[] dependencies, DescriptorPool pool, bool allowUnknownDependencies)
{
this.pool = pool;
this.proto = proto;
this.dependencies = new ReadOnlyCollection<FileDescriptor>((FileDescriptor[]) dependencies.Clone());
publicDependencies = DeterminePublicDependencies(this, proto, dependencies, allowUnknownDependencies);
pool.AddPackage(Package, this);
messageTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.MessageTypeList,
......@@ -80,94 +81,46 @@ namespace Google.ProtocolBuffers.Descriptors
new FieldDescriptor(field, this, null, index, true));
}
/// <summary>
/// Allows a file descriptor to be configured with a set of external options, e.g. from the
/// command-line arguments to protogen.
/// Extracts public dependencies from direct dependencies. This is a static method despite its
/// first parameter, as the value we're in the middle of constructing is only used for exceptions.
/// </summary>
public void ConfigureWithDefaultOptions(CSharpFileOptions options)
{
csharpFileOptions = BuildOrFakeWithDefaultOptions(options);
}
static readonly char[] PathSeperators = new char[] { '/', '\\' };
private CSharpFileOptions BuildOrFakeWithDefaultOptions(CSharpFileOptions defaultOptions)
private static IList<FileDescriptor> DeterminePublicDependencies(FileDescriptor @this, FileDescriptorProto proto, FileDescriptor[] dependencies, bool allowUnknownDependencies)
{
// Fix for being able to relocate these files to any directory structure
if (proto.Package == "google.protobuf")
{
int ixslash = proto.Name.LastIndexOfAny(PathSeperators);
string filename = ixslash < 0 ? proto.Name : proto.Name.Substring(ixslash + 1);
// TODO(jonskeet): Check if we could use FileDescriptorProto.Descriptor.Name - interesting bootstrap issues)
if (filename == "descriptor.proto")
{
return new CSharpFileOptions.Builder
{
Namespace = "Google.ProtocolBuffers.DescriptorProtos",
UmbrellaClassname = "DescriptorProtoFile",
NestClasses = false,
MultipleFiles = false,
PublicClasses = true,
OutputDirectory = defaultOptions.OutputDirectory,
IgnoreGoogleProtobuf = defaultOptions.IgnoreGoogleProtobuf
}.Build();
}
if (filename == "csharp_options.proto")
{
return new CSharpFileOptions.Builder
{
Namespace = "Google.ProtocolBuffers.DescriptorProtos",
UmbrellaClassname = "CSharpOptions",
NestClasses = false,
MultipleFiles = false,
PublicClasses = true,
OutputDirectory = defaultOptions.OutputDirectory,
IgnoreGoogleProtobuf = defaultOptions.IgnoreGoogleProtobuf
}.Build();
}
}
CSharpFileOptions.Builder builder = defaultOptions.ToBuilder();
if (proto.Options.HasExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions))
{
builder.MergeFrom(proto.Options.GetExtension(DescriptorProtos.CSharpOptions.CSharpFileOptions));
}
if (!builder.HasNamespace)
{
builder.Namespace = Package;
}
if (!builder.HasUmbrellaClassname)
var nameToFileMap = new Dictionary<string, FileDescriptor>();
foreach (var file in dependencies)
{
int lastSlash = Name.LastIndexOf('/');
string baseName = Name.Substring(lastSlash + 1);
builder.UmbrellaClassname = NameHelpers.UnderscoresToPascalCase(NameHelpers.StripProto(baseName));
nameToFileMap[file.Name] = file;
}
// Auto-fix for name collision by placing umbrella class into a new namespace. This
// still won't fix the collisions with nesting enabled; however, you have to turn that on explicitly anyway.
if (!builder.NestClasses && !builder.HasUmbrellaNamespace)
var publicDependencies = new List<FileDescriptor>();
for (int i = 0; i < proto.PublicDependencyCount; i++)
{
bool collision = false;
foreach (IDescriptor d in MessageTypes)
{
collision |= d.Name == builder.UmbrellaClassname;
}
foreach (IDescriptor d in Services)
int index = proto.PublicDependencyList[i];
if (index < 0 || index >= proto.DependencyCount)
{
collision |= d.Name == builder.UmbrellaClassname;
throw new DescriptorValidationException(@this, "Invalid public dependency index.");
}
foreach (IDescriptor d in EnumTypes)
string name = proto.DependencyList[index];
FileDescriptor file = nameToFileMap[name];
if (file == null)
{
collision |= d.Name == builder.UmbrellaClassname;
if (!allowUnknownDependencies)
{
throw new DescriptorValidationException(@this, "Invalid public dependency: " + name);
}
// Ignore unknown dependencies.
}
if (collision)
else
{
builder.UmbrellaNamespace = "Proto";
publicDependencies.Add(file);
}
}
return builder.Build();
return new ReadOnlyCollection<FileDescriptor>(publicDependencies);
}
static readonly char[] PathSeperators = new char[] { '/', '\\' };
/// <value>
/// The descriptor in its protocol message representation.
/// </value>
......@@ -184,25 +137,6 @@ namespace Google.ProtocolBuffers.Descriptors
get { return proto.Options; }
}
/// <summary>
/// Returns the C#-specific options for this file descriptor. This will always be
/// completely filled in.
/// </summary>
public CSharpFileOptions CSharpOptions
{
get
{
lock (optionsLock)
{
if (csharpFileOptions == null)
{
csharpFileOptions = BuildOrFakeWithDefaultOptions(CSharpFileOptions.DefaultInstance);
}
}
return csharpFileOptions;
}
}
/// <value>
/// The file name.
/// </value>
......@@ -260,6 +194,14 @@ namespace Google.ProtocolBuffers.Descriptors
get { return dependencies; }
}
/// <value>
/// Unmodifiable list of this file's public dependencies (public imports).
/// </value>
public IList<FileDescriptor> PublicDependencies
{
get { return publicDependencies; }
}
/// <value>
/// Implementation of IDescriptor.FullName - just returns the same as Name.
/// </value>
......@@ -330,6 +272,22 @@ namespace Google.ProtocolBuffers.Descriptors
/// a valid descriptor. This can occur for a number of reasons, such as a field
/// having an undefined type or because two messages were defined with the same name.</exception>
public static FileDescriptor BuildFrom(FileDescriptorProto proto, FileDescriptor[] dependencies)
{
return BuildFrom(proto, dependencies, false);
}
/// <summary>
/// Builds a FileDescriptor from its protocol buffer representation.
/// </summary>
/// <param name="proto">The protocol message form of the FileDescriptor.</param>
/// <param name="dependencies">FileDescriptors corresponding to all of the
/// file's dependencies, in the exact order listed in the .proto file. May be null,
/// in which case it is treated as an empty array.</param>
/// <param name="allowUnknownDependencies">Whether unknown dependencies are ignored (true) or cause an exception to be thrown (false).</param>
/// <exception cref="DescriptorValidationException">If <paramref name="proto"/> is not
/// a valid descriptor. This can occur for a number of reasons, such as a field
/// having an undefined type or because two messages were defined with the same name.</exception>
private static FileDescriptor BuildFrom(FileDescriptorProto proto, FileDescriptor[] dependencies, bool allowUnknownDependencies)
{
// Building descriptors involves two steps: translating and linking.
// In the translation step (implemented by FileDescriptor's
......@@ -346,23 +304,25 @@ namespace Google.ProtocolBuffers.Descriptors
}
DescriptorPool pool = new DescriptorPool(dependencies);
FileDescriptor result = new FileDescriptor(proto, dependencies, pool);
if (dependencies.Length != proto.DependencyCount)
{
throw new DescriptorValidationException(result,
"Dependencies passed to FileDescriptor.BuildFrom() don't match " +
"those listed in the FileDescriptorProto.");
}
for (int i = 0; i < proto.DependencyCount; i++)
{
if (dependencies[i].Name != proto.DependencyList[i])
{
throw new DescriptorValidationException(result,
"Dependencies passed to FileDescriptor.BuildFrom() don't match " +
"those listed in the FileDescriptorProto.");
}
}
FileDescriptor result = new FileDescriptor(proto, dependencies, pool, allowUnknownDependencies);
// TODO(jonskeet): Reinstate these checks, or get rid of them entirely. They aren't in the Java code,
// and fail for the CustomOptions test right now. (We get "descriptor.proto" vs "google/protobuf/descriptor.proto".)
//if (dependencies.Length != proto.DependencyCount)
//{
// throw new DescriptorValidationException(result,
// "Dependencies passed to FileDescriptor.BuildFrom() don't match " +
// "those listed in the FileDescriptorProto.");
//}
//for (int i = 0; i < proto.DependencyCount; i++)
//{
// if (dependencies[i].Name != proto.DependencyList[i])
// {
// throw new DescriptorValidationException(result,
// "Dependencies passed to FileDescriptor.BuildFrom() don't match " +
// "those listed in the FileDescriptorProto.");
// }
//}
result.CrossLink();
return result;
......@@ -434,7 +394,9 @@ namespace Google.ProtocolBuffers.Descriptors
FileDescriptor result;
try
{
result = BuildFrom(proto, dependencies);
// When building descriptors for generated code, we allow unknown
// dependencies by default.
result = BuildFrom(proto, dependencies, true);
}
catch (DescriptorValidationException e)
{
......@@ -494,5 +456,10 @@ namespace Google.ProtocolBuffers.Descriptors
extensions[i].ReplaceProto(proto.GetExtension(i));
}
}
public override string ToString()
{
return "FileDescriptor for " + proto.Name;
}
}
}
\ No newline at end of file
csharp/src/ProtocolBuffers/Descriptors/MessageDescriptor.cs
View file @ f3504cf3
......@@ -158,25 +158,6 @@ namespace Google.ProtocolBuffers.Descriptors
return File.DescriptorPool.FindFieldByNumber(this, number);
}
/// <summary>
/// Finds a field by its property name, as it would be generated by protogen.
/// </summary>
/// <param name="propertyName">The property name within this message type.</param>
/// <returns>The field's descriptor, or null if not found.</returns>
public FieldDescriptor FindFieldByPropertyName(string propertyName)
{
// For reasonably short messages, this will be more efficient than a dictionary
// lookup. It also means we don't need to do things lazily with locks etc.
foreach (FieldDescriptor field in Fields)
{
if (field.CSharpOptions.PropertyName == propertyName)
{
return field;
}
}
return null;
}
/// <summary>
/// Finds a nested descriptor by name. The is valid for fields, nested
/// message types and enums.
......
csharp/src/ProtocolBuffers/ProtocolBuffers.csproj
View file @ f3504cf3
......@@ -68,7 +68,6 @@
<Compile Include="Collections\Dictionaries.cs" />
<Compile Include="Collections\Lists.cs" />
<Compile Include="Collections\ReadOnlyDictionary.cs" />
<Compile Include="DescriptorProtos\CSharpOptions.cs" />
<Compile Include="DescriptorProtos\DescriptorProtoFile.cs" />
<Compile Include="DescriptorProtos\IDescriptorProto.cs" />
<Compile Include="DescriptorProtos\PartialClasses.cs" />
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment