diff options
Diffstat (limited to 'src')
132 files changed, 41539 insertions, 0 deletions
diff --git a/src/ProtoGen.Test/DependencyResolutionTest.cs b/src/ProtoGen.Test/DependencyResolutionTest.cs new file mode 100644 index 00000000..ef911263 --- /dev/null +++ b/src/ProtoGen.Test/DependencyResolutionTest.cs @@ -0,0 +1,95 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Descriptors; +using NUnit.Framework; +using Google.ProtocolBuffers.DescriptorProtos; +using Google.ProtocolBuffers.ProtoGen; + +namespace Google.ProtocolBuffers.ProtoGen { + /// <summary> + /// Tests for the dependency resolution in Generator. + /// </summary> + [TestFixture] + public class DependencyResolutionTest { + + [Test] + public void TwoDistinctFiles() { + FileDescriptorProto first = new FileDescriptorProto.Builder { Name="First" }.Build(); + FileDescriptorProto second = new FileDescriptorProto.Builder { Name="Second" }.Build(); + FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } }; + + IList<FileDescriptor> converted = Generator.ConvertDescriptors(set); + Assert.AreEqual(2, converted.Count); + Assert.AreEqual("First", converted[0].Name); + Assert.AreEqual(0, converted[0].Dependencies.Count); + Assert.AreEqual("Second", converted[1].Name); + Assert.AreEqual(0, converted[1].Dependencies.Count); + } + + [Test] + public void FirstDependsOnSecond() { + FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = {"Second"} }.Build(); + FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second" }.Build(); + FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } }; + IList<FileDescriptor> converted = Generator.ConvertDescriptors(set); + Assert.AreEqual(2, converted.Count); + Assert.AreEqual("First", converted[0].Name); + Assert.AreEqual(1, converted[0].Dependencies.Count); + Assert.AreEqual(converted[1], converted[0].Dependencies[0]); + Assert.AreEqual("Second", converted[1].Name); + Assert.AreEqual(0, converted[1].Dependencies.Count); + } + + [Test] + public void SecondDependsOnFirst() { + FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First" }.Build(); + FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = {"First"} }.Build(); + FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } }; + IList<FileDescriptor> converted = Generator.ConvertDescriptors(set); + Assert.AreEqual(2, converted.Count); + Assert.AreEqual("First", converted[0].Name); + Assert.AreEqual(0, converted[0].Dependencies.Count); + Assert.AreEqual("Second", converted[1].Name); + Assert.AreEqual(1, converted[1].Dependencies.Count); + Assert.AreEqual(converted[0], converted[1].Dependencies[0]); + } + + [Test] + public void CircularDependency() { + FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "Second" } }.Build(); + FileDescriptorProto second = new FileDescriptorProto.Builder { Name = "Second", DependencyList = { "First" } }.Build(); + FileDescriptorSet set = new FileDescriptorSet { FileList = { first, second } }; + try { + Generator.ConvertDescriptors(set); + Assert.Fail("Expected exception"); + } catch (DependencyResolutionException) { + // Expected + } + } + + [Test] + public void MissingDependency() { + FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "Second" } }.Build(); + FileDescriptorSet set = new FileDescriptorSet { FileList = { first } }; + try { + Generator.ConvertDescriptors(set); + Assert.Fail("Expected exception"); + } catch (DependencyResolutionException) { + // Expected + } + } + + [Test] + public void SelfDependency() { + FileDescriptorProto first = new FileDescriptorProto.Builder { Name = "First", DependencyList = { "First" } }.Build(); + FileDescriptorSet set = new FileDescriptorSet { FileList = { first } }; + try { + Generator.ConvertDescriptors(set); + Assert.Fail("Expected exception"); + } catch (DependencyResolutionException) { + // Expected + } + } + } +}
\ No newline at end of file diff --git a/src/ProtoGen.Test/DescriptorUtilTest.cs b/src/ProtoGen.Test/DescriptorUtilTest.cs new file mode 100644 index 00000000..5674892e --- /dev/null +++ b/src/ProtoGen.Test/DescriptorUtilTest.cs @@ -0,0 +1,69 @@ +using Google.ProtocolBuffers.DescriptorProtos; +using Google.ProtocolBuffers.Descriptors; +using NUnit.Framework; + +namespace Google.ProtocolBuffers.ProtoGen { + [TestFixture] + public class DescriptorUtilTest { + + [Test] + public void ExplicitNamespace() { + FileDescriptorProto proto = new FileDescriptorProto.Builder { + Name = "x", Package = "pack", Options = new FileOptions.Builder().SetExtension(CSharpOptions.CSharpNamespace, "Foo.Bar").Build() + }.Build(); + FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null); + Assert.AreEqual("Foo.Bar", DescriptorUtil.GetNamespace(descriptor)); + } + + [Test] + public void NoNamespaceFallsBackToPackage() { + FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "x", Package = "pack" }.Build(); + FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null); + Assert.AreEqual("pack", DescriptorUtil.GetNamespace(descriptor)); + } + + [Test] + public void NoNamespaceOrPackageFallsBackToEmptyString() { + FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "x" }.Build(); + FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null); + Assert.AreEqual("", DescriptorUtil.GetNamespace(descriptor)); + } + + [Test] + public void ExplicitlyNamedFileClass() { + FileDescriptorProto proto = new FileDescriptorProto.Builder { + Name = "x", Options = new FileOptions.Builder().SetExtension(CSharpOptions.CSharpUmbrellaClassname, "Foo").Build() + }.Build(); + FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null); + Assert.AreEqual("Foo", DescriptorUtil.GetUmbrellaClassName(descriptor)); + } + + [Test] + public void ImplicitFileClassWithProtoSuffix() { + FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "foo_bar.proto" }.Build(); + FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null); + Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor)); + } + + [Test] + public void ImplicitFileClassWithProtoDevelSuffix() { + FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "foo_bar.protodevel" }.Build(); + FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null); + Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor)); + } + + [Test] + public void ImplicitFileClassWithNoSuffix() { + FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "foo_bar" }.Build(); + FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null); + Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor)); + } + + [Test] + public void ImplicitFileClassWithDirectoryStructure() { + FileDescriptorProto proto = new FileDescriptorProto.Builder { Name = "x/y/foo_bar" }.Build(); + FileDescriptor descriptor = FileDescriptor.BuildFrom(proto, null); + Assert.AreEqual("FooBar", DescriptorUtil.GetUmbrellaClassName(descriptor)); + } + } +} diff --git a/src/ProtoGen.Test/GeneratorTest.cs b/src/ProtoGen.Test/GeneratorTest.cs new file mode 100644 index 00000000..dbd18787 --- /dev/null +++ b/src/ProtoGen.Test/GeneratorTest.cs @@ -0,0 +1,10 @@ +using Google.ProtocolBuffers.DescriptorProtos; +using NUnit.Framework; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + [TestFixture] + public class GeneratorTest { + + } +}
\ No newline at end of file diff --git a/src/ProtoGen.Test/HelpersTest.cs b/src/ProtoGen.Test/HelpersTest.cs new file mode 100644 index 00000000..af084973 --- /dev/null +++ b/src/ProtoGen.Test/HelpersTest.cs @@ -0,0 +1,33 @@ +using Google.ProtocolBuffers.ProtoGen; +using NUnit.Framework; + +namespace Google.ProtocolBuffers.ProtoGen { + [TestFixture] + public class HelpersTest { + + [Test] + public void UnderscoresToPascalCase() { + Assert.AreEqual("FooBar", Helpers.UnderscoresToPascalCase("Foo_bar")); + Assert.AreEqual("FooBar", Helpers.UnderscoresToPascalCase("foo_bar")); + Assert.AreEqual("Foo0Bar", Helpers.UnderscoresToPascalCase("Foo0bar")); + Assert.AreEqual("FooBar", Helpers.UnderscoresToPascalCase("Foo_+_Bar")); + } + + [Test] + public void UnderscoresToCamelCase() { + Assert.AreEqual("fooBar", Helpers.UnderscoresToCamelCase("Foo_bar")); + Assert.AreEqual("fooBar", Helpers.UnderscoresToCamelCase("foo_bar")); + Assert.AreEqual("foo0Bar", Helpers.UnderscoresToCamelCase("Foo0bar")); + Assert.AreEqual("fooBar", Helpers.UnderscoresToCamelCase("Foo_+_Bar")); + } + + [Test] + public void StripSuffix() { + string text = "FooBar"; + Assert.IsFalse(Helpers.StripSuffix(ref text, "Foo")); + Assert.AreEqual("FooBar", text); + Assert.IsTrue(Helpers.StripSuffix(ref text, "Bar")); + Assert.AreEqual("Foo", text); + } + } +}
\ No newline at end of file diff --git a/src/ProtoGen.Test/Properties/AssemblyInfo.cs b/src/ProtoGen.Test/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..98a0a384 --- /dev/null +++ b/src/ProtoGen.Test/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtoGen.Test")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtoGen.Test")] +[assembly: AssemblyCopyright("Copyright © 2008")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("40720ee3-2d15-4271-8c42-8f9cfd01b52f")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/ProtoGen.Test/Properties/Google.ProtocolBuffers.ProtoGen.Test.snk b/src/ProtoGen.Test/Properties/Google.ProtocolBuffers.ProtoGen.Test.snk Binary files differnew file mode 100644 index 00000000..3f53cbd4 --- /dev/null +++ b/src/ProtoGen.Test/Properties/Google.ProtocolBuffers.ProtoGen.Test.snk diff --git a/src/ProtoGen.Test/ProtoGen.Test.csproj b/src/ProtoGen.Test/ProtoGen.Test.csproj new file mode 100644 index 00000000..805c69ae --- /dev/null +++ b/src/ProtoGen.Test/ProtoGen.Test.csproj @@ -0,0 +1,74 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProductVersion>9.0.30729</ProductVersion> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{C268DA4C-4004-47DA-AF23-44C983281A68}</ProjectGuid> + <OutputType>Library</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>Google.ProtocolBuffers.ProtoGen</RootNamespace> + <AssemblyName>Google.ProtocolBuffers.ProtoGen.Test</AssemblyName> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + <SignAssembly>true</SignAssembly> + <AssemblyOriginatorKeyFile>Properties\Google.ProtocolBuffers.ProtoGen.Test.snk</AssemblyOriginatorKeyFile> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <ItemGroup> + <Reference Include="nunit.framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77"> + <SpecificVersion>False</SpecificVersion> + <HintPath>..\..\lib\nunit.framework.dll</HintPath> + </Reference> + <Reference Include="Rhino.Mocks, Version=3.5.0.2, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL"> + <SpecificVersion>False</SpecificVersion> + <HintPath>..\..\lib\Rhino.Mocks.dll</HintPath> + </Reference> + <Reference Include="System" /> + </ItemGroup> + <ItemGroup> + <Compile Include="DependencyResolutionTest.cs" /> + <Compile Include="DescriptorUtilTest.cs" /> + <Compile Include="GeneratorTest.cs" /> + <Compile Include="HelpersTest.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj"> + <Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project> + <Name>ProtocolBuffers</Name> + </ProjectReference> + <ProjectReference Include="..\ProtoGen\ProtoGen.csproj"> + <Project>{250ADE34-82FD-4BAE-86D5-985FBE589C4A}</Project> + <Name>ProtoGen</Name> + </ProjectReference> + </ItemGroup> + <ItemGroup> + <None Include="Properties\Google.ProtocolBuffers.ProtoGen.Test.snk" /> + </ItemGroup> + <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> + <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + --> +</Project>
\ No newline at end of file diff --git a/src/ProtoGen/DependencyResolutionException.cs b/src/ProtoGen/DependencyResolutionException.cs new file mode 100644 index 00000000..4e483fc1 --- /dev/null +++ b/src/ProtoGen/DependencyResolutionException.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Google.ProtocolBuffers.ProtoGen { + /// <summary> + /// Exception thrown when dependencies within a descriptor set can't be resolved. + /// </summary> + public sealed class DependencyResolutionException : Exception { + public DependencyResolutionException(string message) : base(message) { + } + + public DependencyResolutionException(string format, params object[] args) + : base(string.Format(format, args)) { + } + } +} diff --git a/src/ProtoGen/DescriptorUtil.cs b/src/ProtoGen/DescriptorUtil.cs new file mode 100644 index 00000000..e70ad468 --- /dev/null +++ b/src/ProtoGen/DescriptorUtil.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.ProtoGen { + /// <summary> + /// Utility class for determining namespaces etc. + /// </summary> + internal static class DescriptorUtil { + + internal static bool NestClasses(IDescriptor descriptor) { + // Defaults to false + return descriptor.File.Options.GetExtension(CSharpOptions.CSharpNestClasses); + } + + internal static string GetNamespace(FileDescriptor descriptor) { + if (descriptor.Name == "google/protobuf/descriptor.proto") { + return typeof(DescriptorProtoFile).Namespace; + } + return descriptor.Options.HasExtension(CSharpOptions.CSharpNamespace) ? + descriptor.Options.GetExtension(CSharpOptions.CSharpNamespace) : descriptor.Package; + } + + // Groups are hacky: The name of the field is just the lower-cased name + // of the group type. In C#, though, we would like to retain the original + // capitalization of the type name. + internal static string GetFieldName(FieldDescriptor descriptor) { + if (descriptor.FieldType == FieldType.Group) { + return descriptor.MessageType.Name; + } else { + return descriptor.Name; + } + } + + internal static string GetClassName(IDescriptor descriptor) { + return ToCSharpName(descriptor.FullName, descriptor.File); + } + + internal static string GetFullUmbrellaClassName(FileDescriptor descriptor) { + string result = GetNamespace(descriptor); + if (result != "") result += '.'; + result += GetUmbrellaClassName(descriptor); + return "global::" + result; + } + + internal static string GetUmbrellaClassName(FileDescriptor descriptor) { + if (descriptor.Name == "google/protobuf/descriptor.proto") { + return typeof(DescriptorProtoFile).Name; + } + FileOptions options = descriptor.Options; + if (options.HasExtension(CSharpOptions.CSharpUmbrellaClassname)) { + return descriptor.Options.GetExtension(CSharpOptions.CSharpUmbrellaClassname); + } + int lastSlash = descriptor.Name.LastIndexOf('/'); + string baseName = descriptor.Name.Substring(lastSlash + 1); + return Helpers.UnderscoresToPascalCase(StripProto(baseName)); + } + + private static string StripProto(string text) { + if (!Helpers.StripSuffix(ref text, ".protodevel")) { + Helpers.StripSuffix(ref text, ".proto"); + } + return text; + } + + private static string ToCSharpName(string name, FileDescriptor file) { + string result; + if (!NestClasses(file)) { + result = GetNamespace(file); + } else { + result = GetUmbrellaClassName(file); + } + if (result != "") { + result += '.'; + } + string classname; + if (file.Package == "") { + classname = name; + } else { + // Strip the proto package from full_name since we've replaced it with + // the C# namespace. + classname = name.Substring(file.Package.Length + 1); + } + result += classname.Replace(".", ".Types."); + return "global::" + result; + } + + internal static string GetMappedTypeName(MappedType type) { + switch(type) { + case MappedType.Int32: return "int"; + case MappedType.Int64: return "long"; + case MappedType.UInt32: return "uint"; + case MappedType.UInt64: return "ulong"; + case MappedType.Single: return "float"; + case MappedType.Double: return "double"; + case MappedType.Boolean: return "bool"; + case MappedType.String: return "string"; + case MappedType.ByteString: return "pb::ByteString"; + case MappedType.Enum: return null; + case MappedType.Message: return null; + default: + throw new ArgumentOutOfRangeException("Unknown mapped type " + type); + } + } + } +} diff --git a/src/ProtoGen/EnumFieldGenerator.cs b/src/ProtoGen/EnumFieldGenerator.cs new file mode 100644 index 00000000..9f6a56f2 --- /dev/null +++ b/src/ProtoGen/EnumFieldGenerator.cs @@ -0,0 +1,75 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class EnumFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator { + internal EnumFieldGenerator(FieldDescriptor descriptor) + : base(descriptor) { + } + + public void GenerateMembers(TextGenerator writer) { + writer.WriteLine("private bool has{0};", CapitalizedName); + writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue); + writer.WriteLine("public bool Has{0} {{", CapitalizedName); + writer.WriteLine(" get {{ return has{0}; }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public {0} {1} {{", TypeName, PropertyName); + writer.WriteLine(" get {{ return {0}_; }}", Name); + writer.WriteLine("}"); + } + + public void GenerateBuilderMembers(TextGenerator writer) { + writer.WriteLine("public bool Has{0} {{", CapitalizedName); + writer.WriteLine(" get {{ return result.Has{0}; }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public {0} {1} {{", TypeName, PropertyName); + writer.WriteLine(" get {{ return result.{0}; }}", PropertyName); + writer.WriteLine(" set {{ Set{0}(value); }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public Builder Set{0}({1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.has{0} = true;", CapitalizedName); + writer.WriteLine(" result.{0}_ = value;", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName); + writer.WriteLine(" result.has{0} = false;", CapitalizedName); + writer.WriteLine(" result.{0}_ = {1};", Name, DefaultValue); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + } + + public void GenerateMergingCode(TextGenerator writer) { + writer.WriteLine("if (other.Has{0}) {{", CapitalizedName); + writer.WriteLine(" {0} = other.{0};", PropertyName); + writer.WriteLine("}"); + } + + public void GenerateBuildingCode(TextGenerator writer) { + // Nothing to do here for enum types + } + + public void GenerateParsingCode(TextGenerator writer) { + // TODO(jonskeet): Make a more efficient way of doing this + writer.WriteLine("int rawValue = input.ReadEnum();"); + writer.WriteLine("if (!global::System.Enum.IsDefined(typeof({0}), rawValue)) {{", TypeName); + writer.WriteLine(" unknownFields.MergeVarintField({0}, (ulong) rawValue);", Number); + writer.WriteLine("} else {"); + writer.WriteLine(" {0} = ({1}) rawValue;", PropertyName, TypeName); + writer.WriteLine("}"); + } + + public void GenerateSerializationCode(TextGenerator writer) { + writer.WriteLine("if (Has{0}) {{", CapitalizedName); + writer.WriteLine(" output.WriteEnum({0}, (int) {1});", Number, PropertyName); + writer.WriteLine("}"); + } + + public void GenerateSerializedSizeCode(TextGenerator writer) { + writer.WriteLine("if (Has{0}) {{", CapitalizedName); + writer.WriteLine(" size += pb::CodedOutputStream.ComputeEnumSize({0}, (int) {1});", Number, PropertyName); + writer.WriteLine("}"); + } + } +} diff --git a/src/ProtoGen/EnumGenerator.cs b/src/ProtoGen/EnumGenerator.cs new file mode 100644 index 00000000..0de6b89c --- /dev/null +++ b/src/ProtoGen/EnumGenerator.cs @@ -0,0 +1,19 @@ +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class EnumGenerator : SourceGeneratorBase<EnumDescriptor>, ISourceGenerator { + internal EnumGenerator(EnumDescriptor descriptor) : base(descriptor) { + } + + public void Generate(TextGenerator writer) { + writer.WriteLine("{0} enum {1} {{", ClassAccessLevel, Descriptor.Name); + writer.Indent(); + foreach (EnumValueDescriptor value in Descriptor.Values) { + writer.WriteLine("{0} = {1},", value.Name, value.Number); + } + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + } +} diff --git a/src/ProtoGen/ExtensionGenerator.cs b/src/ProtoGen/ExtensionGenerator.cs new file mode 100644 index 00000000..9c235456 --- /dev/null +++ b/src/ProtoGen/ExtensionGenerator.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class ExtensionGenerator : SourceGeneratorBase<FieldDescriptor>, ISourceGenerator { + internal ExtensionGenerator(FieldDescriptor descriptor) : base(descriptor) { + } + + public void Generate(TextGenerator writer) { + string name = Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(Descriptor)); + + string type; + switch (Descriptor.MappedType) { + case MappedType.Message: + type = DescriptorUtil.GetClassName(Descriptor.MessageType); + break; + case MappedType.Enum: + type = DescriptorUtil.GetClassName(Descriptor.EnumType); + break; + default: + type = DescriptorUtil.GetMappedTypeName(Descriptor.MappedType); + break; + } + + if (Descriptor.IsRepeated) { + writer.WriteLine("{0} static readonly", ClassAccessLevel); + writer.WriteLine(" pb::GeneratedExtensionBase<scg::IList<{0}>> {1} =", type, name); + writer.WriteLine(" pb::GeneratedRepeatExtension<{0}>.CreateInstance(Descriptor.Extensions[{1}]);", type, Descriptor.Index); + } else { + writer.WriteLine("{0} static readonly pb::GeneratedExtensionBase<{1}> {2} =", ClassAccessLevel, type, name); + writer.WriteLine(" pb::GeneratedSingleExtension<{0}>.CreateInstance(Descriptor.Extensions[{1}]);", type, Descriptor.Index); + } + } + } +} diff --git a/src/ProtoGen/FieldGeneratorBase.cs b/src/ProtoGen/FieldGeneratorBase.cs new file mode 100644 index 00000000..d050ac84 --- /dev/null +++ b/src/ProtoGen/FieldGeneratorBase.cs @@ -0,0 +1,130 @@ +using System; +using Google.ProtocolBuffers.Descriptors; +using System.Globalization; + +namespace Google.ProtocolBuffers.ProtoGen { + internal abstract class FieldGeneratorBase : SourceGeneratorBase<FieldDescriptor> { + protected FieldGeneratorBase(FieldDescriptor descriptor) + : base(descriptor) { + } + + private static bool AllPrintableAscii(string text) { + foreach (char c in text) { + if (c < 0x20 || c > 0x7e) { + return false; + } + } + return true; + } + + protected string DefaultValue { + get { + string suffix = ""; + switch (Descriptor.FieldType) { + case FieldType.Float: suffix = "F"; break; + case FieldType.Double: suffix = "D"; break; + case FieldType.Int64: suffix = "L"; break; + case FieldType.UInt64: suffix = "UL"; break; + } + switch (Descriptor.FieldType) { + case FieldType.Float: + case FieldType.Double: + case FieldType.Int32: + case FieldType.Int64: + case FieldType.SInt32: + case FieldType.SInt64: + case FieldType.SFixed32: + case FieldType.SFixed64: + case FieldType.UInt32: + case FieldType.UInt64: + case FieldType.Fixed32: + case FieldType.Fixed64: + // The simple Object.ToString converts using the current culture. + // We want to always use the invariant culture so it's predictable. + IConvertible value = (IConvertible) Descriptor.DefaultValue; + return value.ToString(CultureInfo.InvariantCulture) + suffix; + case FieldType.Bool: + return (bool) Descriptor.DefaultValue ? "true" : "false"; + + case FieldType.Bytes: + if (!Descriptor.HasDefaultValue) { + return "pb::ByteString.Empty"; + } + return string.Format("(pb::ByteString) {0}.Descriptor.Fields[{1}].DefaultValue", DescriptorUtil.GetClassName(Descriptor.ContainingType), Descriptor.Index); + case FieldType.String: + if (AllPrintableAscii(Descriptor.Proto.DefaultValue)) { + // All chars are ASCII and printable. In this case we only + // need to escape quotes and backslashes. + return "\"" + Descriptor.Proto.DefaultValue + .Replace("\\", "\\\\") + .Replace("'", "\\'") + .Replace("\"", "\\\"") + + "\""; + } + return string.Format("(string) {0}.Descriptor.Fields[{1}].DefaultValue", DescriptorUtil.GetClassName(Descriptor.ContainingType), Descriptor.Index); + case FieldType.Enum: + return TypeName + "." + ((EnumValueDescriptor) Descriptor.DefaultValue).Name; + case FieldType.Message: + case FieldType.Group: + return TypeName + ".DefaultInstance"; + default: + throw new InvalidOperationException("Invalid field descriptor type"); + } + } + } + + /// <summary> + /// Usually the same as CapitalizedName, except when the enclosing type has the same name, + /// in which case an underscore is appended. + /// </summary> + protected string PropertyName { + get { + string ret = CapitalizedName; + if (ret == Descriptor.ContainingType.Name) { + ret += "_"; + } + return ret; + } + } + + protected string CapitalizedName { + get { return Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(Descriptor)); } + } + + protected string Name { + get { return Helpers.UnderscoresToCamelCase(DescriptorUtil.GetFieldName(Descriptor)); } + } + + protected int Number { + get { return Descriptor.FieldNumber; } + } + + protected string TypeName { + get { + switch (Descriptor.FieldType) { + case FieldType.Enum: + return DescriptorUtil.GetClassName(Descriptor.EnumType); + case FieldType.Message: + case FieldType.Group: + return DescriptorUtil.GetClassName(Descriptor.MessageType); + default: + return DescriptorUtil.GetMappedTypeName(Descriptor.MappedType); + } + } + } + + protected string MessageOrGroup { + get { return Descriptor.FieldType == FieldType.Group ? "Group" : "Message"; } + } + + /// <summary> + /// Returns the type name as used in CodedInputStream method names: SFixed32, UInt32 etc. + /// </summary> + protected string CapitalizedTypeName { + get { + // Our enum names match perfectly. How serendipitous. + return Descriptor.FieldType.ToString(); + } + } + } +} diff --git a/src/ProtoGen/Generator.cs b/src/ProtoGen/Generator.cs new file mode 100644 index 00000000..f656386b --- /dev/null +++ b/src/ProtoGen/Generator.cs @@ -0,0 +1,138 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.DescriptorProtos; +using System.IO; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.Collections; + +namespace Google.ProtocolBuffers.ProtoGen { + /// <summary> + /// Code generator for protocol buffers. Only C# is supported at the moment. + /// </summary> + public sealed class Generator { + + readonly GeneratorOptions options; + + private Generator(GeneratorOptions options) { + options.Validate(); + this.options = options; + } + + /// <summary> + /// Returns a generator configured with the specified options. + /// </summary> + public static Generator CreateGenerator(GeneratorOptions options) { + return new Generator(options); + } + + public void Generate() { + foreach (string inputFile in options.InputFiles) { + FileDescriptorSet descriptorProtos; + ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance(); + extensionRegistry.Add(CSharpOptions.CSharpUmbrellaClassname); + extensionRegistry.Add(CSharpOptions.CSharpMultipleFiles); + extensionRegistry.Add(CSharpOptions.CSharpNamespace); + extensionRegistry.Add(CSharpOptions.CSharpNestClasses); + extensionRegistry.Add(CSharpOptions.CSharpPublicClasses); + using (Stream inputStream = File.OpenRead(inputFile)) { + descriptorProtos = FileDescriptorSet.ParseFrom(inputStream, extensionRegistry); + } + IList<FileDescriptor> descriptors = ConvertDescriptors(descriptorProtos); + + foreach (FileDescriptor descriptor in descriptors) { + Generate(descriptor); + } + } + } + + /// <summary> + /// Generates code for a particular file. All dependencies must + /// already have been resolved. + /// </summary> + private void Generate(FileDescriptor descriptor) { + string umbrellaClass = DescriptorUtil.GetUmbrellaClassName(descriptor); + string ns = DescriptorUtil.GetNamespace(descriptor); + using (TextWriter textWriter = File.CreateText(Path.Combine(options.OutputDirectory, umbrellaClass + ".cs"))) { + TextGenerator writer = new TextGenerator(textWriter); + + UmbrellaClassGenerator ucg = new UmbrellaClassGenerator(descriptor); + ucg.Generate(writer); + /* + GenerateSiblings(umbrellaSource, descriptor, descriptor.MessageTypes); + GenerateSiblings(umbrellaSource, descriptor, descriptor.EnumTypes); + GenerateSiblings(umbrellaSource, descriptor, descriptor.Services);*/ + } + } + + private static void GenerateSiblings<T>(SourceFileGenerator parentSourceGenerator, FileDescriptor file, IEnumerable<T> siblings) + where T : IDescriptor { + } + + /// <summary> + /// Resolves any dependencies and converts FileDescriptorProtos into FileDescriptors. + /// The list returned is in the same order as the protos are listed in the descriptor set. + /// Note: this method is internal rather than private to allow testing. + /// </summary> + /// <exception cref="DependencyResolutionException">Not all dependencies could be resolved.</exception> + internal static IList<FileDescriptor> ConvertDescriptors(FileDescriptorSet descriptorProtos) { + // Simple strategy: Keep going through the list of protos to convert, only doing ones where + // we've already converted all the dependencies, until we get to a stalemate + IList<FileDescriptorProto> fileList = descriptorProtos.FileList; + FileDescriptor[] converted = new FileDescriptor[fileList.Count]; + + Dictionary<string, FileDescriptor> convertedMap = new Dictionary<string, FileDescriptor>(); + + int totalConverted = 0; + + bool madeProgress = true; + while (madeProgress && totalConverted < converted.Length) { + madeProgress = false; + for (int i = 0; i < converted.Length; i++) { + if (converted[i] != null) { + // Already done this one + continue; + } + FileDescriptorProto candidate = fileList[i]; + FileDescriptor[] dependencies = new FileDescriptor[candidate.DependencyList.Count]; + bool foundAllDependencies = true; + for (int j = 0; j < dependencies.Length; j++) { + if (!convertedMap.TryGetValue(candidate.DependencyList[j], out dependencies[j])) { + foundAllDependencies = false; + break; + } + } + if (!foundAllDependencies) { + continue; + } + madeProgress = true; + totalConverted++; + converted[i] = FileDescriptor.BuildFrom(candidate, dependencies); + convertedMap[candidate.Name] = converted[i]; + } + } + if (!madeProgress) { + StringBuilder remaining = new StringBuilder(); + for (int i = 0; i < converted.Length; i++) { + if (converted[i] == null) { + if (remaining.Length != 0) { + remaining.Append(", "); + } + FileDescriptorProto failure = fileList[i]; + remaining.Append(failure.Name); + remaining.Append(":"); + foreach (string dependency in failure.DependencyList) { + if (!convertedMap.ContainsKey(dependency)) { + remaining.Append(" "); + remaining.Append(dependency); + } + } + remaining.Append(";"); + } + } + throw new DependencyResolutionException("Unable to resolve all dependencies: " + remaining); + } + return Lists.AsReadOnly(converted); + } + } +} diff --git a/src/ProtoGen/GeneratorOptions.cs b/src/ProtoGen/GeneratorOptions.cs new file mode 100644 index 00000000..c37352ed --- /dev/null +++ b/src/ProtoGen/GeneratorOptions.cs @@ -0,0 +1,69 @@ +using System.Collections.Generic; +using System.IO; + +namespace Google.ProtocolBuffers.ProtoGen { + + /// <summary> + /// All the configuration required for the generator - where to generate + /// output files, the location of input files etc. While this isn't immutable + /// in practice, the contents shouldn't be changed after being passed to + /// the generator. + /// </summary> + public sealed class GeneratorOptions { + + public string OutputDirectory { get; set; } + public IList<string> InputFiles { get; set; } + + /// <summary> + /// Attempts to validate the options, but doesn't throw an exception if they're invalid. + /// Instead, when this method returns false, the output variable will contain a collection + /// of reasons for the validation failure. + /// </summary> + /// <param name="reasons">Variable to receive a list of reasons in case of validation failure.</param> + /// <returns>true if the options are valid; false otherwise</returns> + public bool TryValidate(out IList<string> reasons) { + List<string> tmpReasons = new List<string>(); + + // Output directory validation + if (string.IsNullOrEmpty(OutputDirectory)) { + tmpReasons.Add("No output directory specified"); + } else { + if (!Directory.Exists(OutputDirectory)) { + tmpReasons.Add("Specified output directory (" + OutputDirectory + " doesn't exist."); + } + } + + // Input file validation (just in terms of presence) + if (InputFiles == null || InputFiles.Count == 0) { + tmpReasons.Add("No input files specified"); + } else { + foreach (string input in InputFiles) { + FileInfo fi = new FileInfo(input); + if (!fi.Exists) { + tmpReasons.Add("Input file " + input + " doesn't exist."); + } + } + } + + if (tmpReasons.Count != 0) { + reasons = tmpReasons; + return false; + } + + reasons = null; + return true; + } + + /// <summary> + /// Validates that all the options have been set and are valid, + /// throwing an exception if they haven't. + /// </summary> + /// <exception cref="InvalidOptionsException">The options are invalid.</exception> + public void Validate() { + IList<string> reasons; + if (!TryValidate(out reasons)) { + throw new InvalidOptionsException(reasons); + } + } + } +} diff --git a/src/ProtoGen/Helpers.cs b/src/ProtoGen/Helpers.cs new file mode 100644 index 00000000..79a2912c --- /dev/null +++ b/src/ProtoGen/Helpers.cs @@ -0,0 +1,78 @@ +using System; +using System.Text; +using Google.ProtocolBuffers.DescriptorProtos; +using Google.ProtocolBuffers.Descriptors; +namespace Google.ProtocolBuffers.ProtoGen { + + /// <summary> + /// Helpers to resolve class names etc. + /// </summary> + internal static class Helpers { + internal static string UnderscoresToPascalCase(string input) { + return UnderscoresToPascalOrCamelCase(input, true); + } + + internal static string UnderscoresToCamelCase(string input) { + return UnderscoresToPascalOrCamelCase(input, false); + } + + internal static void WriteNamespaces(TextGenerator writer) { + writer.WriteLine("using pb = global::Google.ProtocolBuffers;"); + writer.WriteLine("using pbc = global::Google.ProtocolBuffers.Collections;"); + writer.WriteLine("using pbd = global::Google.ProtocolBuffers.Descriptors;"); + writer.WriteLine("using scg = global::System.Collections.Generic;"); + } + + /// <summary> + /// Converts a string to Pascal or Camel case. The first letter is capitalized or + /// lower-cased depending on <paramref name="pascal"/> is true. + /// After the first letter, any punctuation is removed but triggers capitalization + /// of the next letter. Digits are preserved but trigger capitalization of the next + /// letter. + /// All capitalisation is done in the invariant culture. + /// </summary> + private static string UnderscoresToPascalOrCamelCase(string input, bool pascal) { + StringBuilder result = new StringBuilder(); + bool capitaliseNext = pascal; + for (int i=0; i < input.Length; i++) { + char c = input[i]; + if ('a' <= c && c <= 'z') { + if (capitaliseNext) { + result.Append(char.ToUpperInvariant(c)); + } else { + result.Append(c); + } + capitaliseNext = false; + } else if ('A' <= c && c <= 'Z') { + if (i == 0 && !pascal) { + // Force first letter to lower-case unless explicitly told to + // capitalize it. + result.Append(char.ToLowerInvariant(c)); + } else { + // Capital letters after the first are left as-is. + result.Append(c); + } + capitaliseNext = false; + } else if ('0' <= c && c <= '9') { + result.Append(c); + capitaliseNext = true; + } else { + capitaliseNext = true; + } + } + return result.ToString(); + } + + /// <summary> + /// Attempts to strip a suffix from a string, returning whether + /// or not the suffix was actually present. + /// </summary> + internal static bool StripSuffix(ref string text, string suffix) { + if (text.EndsWith(suffix)) { + text = text.Substring(0, text.Length - suffix.Length); + return true; + } + return false; + } + } +} diff --git a/src/ProtoGen/IFieldSourceGenerator.cs b/src/ProtoGen/IFieldSourceGenerator.cs new file mode 100644 index 00000000..a64043c8 --- /dev/null +++ b/src/ProtoGen/IFieldSourceGenerator.cs @@ -0,0 +1,11 @@ +namespace Google.ProtocolBuffers.ProtoGen { + internal interface IFieldSourceGenerator { + void GenerateMembers(TextGenerator writer); + void GenerateBuilderMembers(TextGenerator writer); + void GenerateMergingCode(TextGenerator writer); + void GenerateBuildingCode(TextGenerator writer); + void GenerateParsingCode(TextGenerator writer); + void GenerateSerializationCode(TextGenerator writer); + void GenerateSerializedSizeCode(TextGenerator writer); + } +} diff --git a/src/ProtoGen/ISourceGenerator.cs b/src/ProtoGen/ISourceGenerator.cs new file mode 100644 index 00000000..16e7c29a --- /dev/null +++ b/src/ProtoGen/ISourceGenerator.cs @@ -0,0 +1,5 @@ +namespace Google.ProtocolBuffers.ProtoGen { + internal interface ISourceGenerator { + void Generate(TextGenerator writer); + } +} diff --git a/src/ProtoGen/InvalidOptionsException.cs b/src/ProtoGen/InvalidOptionsException.cs new file mode 100644 index 00000000..aee03228 --- /dev/null +++ b/src/ProtoGen/InvalidOptionsException.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Collections; + +namespace Google.ProtocolBuffers.ProtoGen { + /// <summary> + /// Exception thrown to indicate that the options passed were invalid. + /// </summary> + public sealed class InvalidOptionsException : Exception { + + private readonly IList<string> reasons; + + /// <summary> + /// An immutable list of reasons why the options were invalid. + /// </summary> + public IList<string> Reasons { + get { return reasons; } + } + + public InvalidOptionsException(IList<string> reasons) + : base(BuildMessage(reasons)) { + this.reasons = Lists.AsReadOnly(reasons); + } + + private static string BuildMessage(IEnumerable<string> reasons) { + StringBuilder builder = new StringBuilder("Invalid options:"); + builder.AppendLine(); + foreach (string reason in reasons) { + builder.Append(" "); + builder.AppendLine(reason); + } + return builder.ToString(); + } + } +} diff --git a/src/ProtoGen/MessageFieldGenerator.cs b/src/ProtoGen/MessageFieldGenerator.cs new file mode 100644 index 00000000..c73edfc0 --- /dev/null +++ b/src/ProtoGen/MessageFieldGenerator.cs @@ -0,0 +1,92 @@ +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class MessageFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator { + + internal MessageFieldGenerator(FieldDescriptor descriptor) + : base(descriptor) { + } + + public void GenerateMembers(TextGenerator writer) { + writer.WriteLine("private bool has{0};", CapitalizedName); + writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue); + writer.WriteLine("public bool Has{0} {{", CapitalizedName); + writer.WriteLine(" get {{ return has{0}; }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public {0} {1} {{", TypeName, CapitalizedName); + writer.WriteLine(" get {{ return {0}_; }}", Name); + writer.WriteLine("}"); + } + + public void GenerateBuilderMembers(TextGenerator writer) { + writer.WriteLine("public bool Has{0} {{", CapitalizedName); + writer.WriteLine(" get {{ return result.Has{0}; }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public {0} {1} {{", TypeName, CapitalizedName); + writer.WriteLine(" get {{ return result.{0}; }}", CapitalizedName); + writer.WriteLine(" set {{ Set{0}(value); }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public Builder Set{0}({1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.has{0} = true;", CapitalizedName); + writer.WriteLine(" result.{0}_ = value;", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Set{0}({1}.Builder builderForValue) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.has{0} = true;", CapitalizedName); + writer.WriteLine(" result.{0}_ = builderForValue.Build();", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Merge{0}({1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" if (result.Has{0} &&", CapitalizedName); + writer.WriteLine(" result.{0}_ != {1}) {{", Name, DefaultValue); + writer.WriteLine(" result.{0}_ = {1}.CreateBuilder(result.{0}_).MergeFrom(value).BuildPartial();", Name, TypeName); + writer.WriteLine(" } else {"); + writer.WriteLine(" result.{0}_ = value;", Name); + writer.WriteLine(" }"); + writer.WriteLine(" result.has{0} = true;", CapitalizedName); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName); + writer.WriteLine(" result.has{0} = false;", CapitalizedName); + writer.WriteLine(" result.{0}_ = {1};", Name, DefaultValue); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + } + + public void GenerateMergingCode(TextGenerator writer) { + writer.WriteLine("if (other.Has{0}) {{", CapitalizedName); + writer.WriteLine(" Merge{0}(other.{0});", CapitalizedName); + writer.WriteLine("}"); + } + + public void GenerateBuildingCode(TextGenerator writer) { + // Nothing to do for singular fields + } + + public void GenerateParsingCode(TextGenerator writer) { + writer.WriteLine("{0}.Builder subBuilder = {0}.CreateBuilder();", TypeName); + writer.WriteLine("if (Has{0}) {{", CapitalizedName); + writer.WriteLine(" subBuilder.MergeFrom({0});", CapitalizedName); + writer.WriteLine("}"); + if (Descriptor.FieldType == FieldType.Group) { + writer.WriteLine("input.ReadGroup({0}, subBuilder, extensionRegistry);", Number); + } else { + writer.WriteLine("input.ReadMessage(subBuilder, extensionRegistry);"); + } + writer.WriteLine("{0} = subBuilder.BuildPartial();", CapitalizedName); + } + + public void GenerateSerializationCode(TextGenerator writer) { + writer.WriteLine("if (Has{0}) {{", CapitalizedName); + writer.WriteLine(" output.Write{0}({1}, {2});", MessageOrGroup, Number, CapitalizedName); + writer.WriteLine("}"); + } + + public void GenerateSerializedSizeCode(TextGenerator writer) { + writer.WriteLine("if (Has{0}) {{", CapitalizedName); + writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, {2});", + MessageOrGroup, Number, CapitalizedName); + writer.WriteLine("}"); + } + } +} diff --git a/src/ProtoGen/MessageGenerator.cs b/src/ProtoGen/MessageGenerator.cs new file mode 100644 index 00000000..95de1a38 --- /dev/null +++ b/src/ProtoGen/MessageGenerator.cs @@ -0,0 +1,453 @@ +using System.Collections; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.DescriptorProtos; +using System.Collections.Generic; + +using ExtensionRange = Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class MessageGenerator : SourceGeneratorBase<MessageDescriptor>, ISourceGenerator { + internal MessageGenerator(MessageDescriptor descriptor) : base(descriptor) { + } + + private string ClassName { + get { return Descriptor.Name; } + } + + private string FullClassName { + get { return DescriptorUtil.GetClassName(Descriptor); } + } + + /// <summary> + /// Get an identifier that uniquely identifies this type within the file. + /// This is used to declare static variables related to this type at the + /// outermost file scope. + /// </summary> + static string GetUniqueFileScopeIdentifier(IDescriptor descriptor) { + return "static_" + descriptor.FullName.Replace(".", "_"); + } + + internal void GenerateStaticVariables(TextGenerator writer) { + // Because descriptor.proto (Google.ProtocolBuffers.DescriptorProtos) is + // used in the construction of descriptors, we have a tricky bootstrapping + // problem. To help control static initialization order, we make sure all + // descriptors and other static data that depends on them are members of + // the proto-descriptor class. This way, they will be initialized in + // a deterministic order. + + string identifier = GetUniqueFileScopeIdentifier(Descriptor); + + // The descriptor for this type. + string access = Descriptor.File.Options.GetExtension(CSharpOptions.CSharpNestClasses) ? "private" : "internal"; + writer.WriteLine("{0} static readonly pbd::MessageDescriptor internal__{1}__Descriptor", access, identifier); + if (Descriptor.ContainingType == null) { + writer.WriteLine(" = Descriptor.MessageTypes[{0}];", Descriptor.Index); + } else { + writer.WriteLine(" = internal__{0}__Descriptor.NestedTypes[{1}];", GetUniqueFileScopeIdentifier(Descriptor.ContainingType), Descriptor.Index); + } + writer.WriteLine("{0} static pb::FieldAccess.FieldAccessorTable<{1}, {1}.Builder> internal__{2}__FieldAccessorTable", + access, FullClassName, identifier); + writer.WriteLine(" = new pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder>(internal__{1}__Descriptor,", + FullClassName, identifier); + writer.Print(" new string[] { "); + foreach (FieldDescriptor field in Descriptor.Fields) { + writer.Write("\"{0}\", ", Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(field))); + } + writer.WriteLine("});"); + + // Generate static members for all nested types. + foreach (MessageDescriptor nestedMessage in Descriptor.NestedTypes) { + new MessageGenerator(nestedMessage).GenerateStaticVariables(writer); + } + } + + public void Generate(TextGenerator writer) { + writer.WriteLine("{0} sealed partial class {1} : pb::{2}Message<{1}, {1}.Builder> {{", + ClassAccessLevel, ClassName, Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated"); + writer.Indent(); + // Must call BuildPartial() to make sure all lists are made read-only + writer.WriteLine("private static readonly {0} defaultInstance = new Builder().BuildPartial();", ClassName); + writer.WriteLine("public static {0} DefaultInstance {{", ClassName); + writer.WriteLine(" get { return defaultInstance; }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName); + writer.WriteLine(" get { return defaultInstance; }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("protected override {0} ThisMessage {{", ClassName); + writer.WriteLine(" get { return this; }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public static pbd::MessageDescriptor Descriptor {"); + writer.WriteLine(" get {{ return {0}.internal__{1}__Descriptor; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor.File), + GetUniqueFileScopeIdentifier(Descriptor)); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("protected override pb::FieldAccess.FieldAccessorTable<{0}, {0}.Builder> InternalFieldAccessors {{", ClassName); + writer.WriteLine(" get {{ return {0}.internal__{1}__FieldAccessorTable; }}", DescriptorUtil.GetFullUmbrellaClassName(Descriptor.File), + GetUniqueFileScopeIdentifier(Descriptor)); + writer.WriteLine("}"); + writer.WriteLine(); + + // Extensions don't need to go in an extra nested type + WriteChildren(writer, null, Descriptor.Extensions); + + if (Descriptor.EnumTypes.Count + Descriptor.NestedTypes.Count > 0) { + writer.WriteLine("#region Nested types"); + writer.WriteLine("public static class Types {"); + writer.Indent(); + WriteChildren(writer, null, Descriptor.EnumTypes); + WriteChildren(writer, null, Descriptor.NestedTypes); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine("#endregion"); + writer.WriteLine(); + } + + foreach(FieldDescriptor fieldDescriptor in Descriptor.Fields) { + // Rats: we lose the debug comment here :( + SourceGenerators.CreateFieldGenerator(fieldDescriptor).GenerateMembers(writer); + writer.WriteLine(); + } + + if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) { + GenerateIsInitialized(writer); + GenerateMessageSerializationMethods(writer); + } + + GenerateParseFromMethods(writer); + GenerateBuilder(writer); + } + + private void GenerateMessageSerializationMethods(TextGenerator writer) { + List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields); + sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber)); + + List<ExtensionRange> sortedExtensions = new List<ExtensionRange>(Descriptor.Proto.ExtensionRangeList); + sortedExtensions.Sort((r1, r2) => (r1.Start.CompareTo(r2.Start))); + + writer.WriteLine("public override void WriteTo(pb::CodedOutputStream output) {"); + writer.Indent(); + if (Descriptor.Proto.ExtensionRangeList.Count > 0) { + writer.WriteLine("pb::ExtendableMessage<{0}, {0}.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);", + ClassName); + } + + // Merge the fields and the extension ranges, both sorted by field number. + for (int i = 0, j = 0; i < Descriptor.Fields.Count || j < sortedExtensions.Count; ) { + if (i == Descriptor.Fields.Count) { + GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]); + } else if (j == sortedExtensions.Count) { + GenerateSerializeOneField(writer, sortedFields[i++]); + } else if (sortedFields[i].FieldNumber < sortedExtensions[j].Start) { + GenerateSerializeOneField(writer, sortedFields[i++]); + } else { + GenerateSerializeOneExtensionRange(writer, sortedExtensions[j++]); + } + } + + if (Descriptor.Proto.Options.MessageSetWireFormat) { + writer.WriteLine("UnknownFields.WriteAsMessageSetTo(output);"); + } else { + writer.WriteLine("UnknownFields.WriteTo(output);"); + } + + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("private int memoizedSerializedSize = -1;"); + writer.WriteLine("public override int SerializedSize {"); + writer.Indent(); + writer.WriteLine("get {"); + writer.Indent(); + writer.WriteLine("int size = memoizedSerializedSize;"); + writer.WriteLine("if (size != -1) return size;"); + writer.WriteLine(); + writer.WriteLine("size = 0;"); + foreach (FieldDescriptor field in Descriptor.Fields) { + SourceGenerators.CreateFieldGenerator(field).GenerateSerializedSizeCode(writer); + } + if (Descriptor.Proto.ExtensionRangeCount > 0) { + writer.WriteLine("size += ExtensionsSerializedSize;"); + } + + if (Descriptor.Options.MessageSetWireFormat) { + writer.WriteLine("size += UnknownFields.SerializedSizeAsMessageSet;"); + } else { + writer.WriteLine("size += UnknownFields.SerializedSize;"); + } + writer.WriteLine("memoizedSerializedSize = size;"); + writer.WriteLine("return size;"); + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + + private static void GenerateSerializeOneField(TextGenerator writer, FieldDescriptor fieldDescriptor) { + SourceGenerators.CreateFieldGenerator(fieldDescriptor).GenerateSerializationCode(writer); + } + + private static void GenerateSerializeOneExtensionRange(TextGenerator writer, ExtensionRange extensionRange) { + writer.WriteLine("extensionWriter.WriteUntil({0}, output);", extensionRange.End); + } + + private void GenerateParseFromMethods(TextGenerator writer) { + // Note: These are separate from GenerateMessageSerializationMethods() + // because they need to be generated even for messages that are optimized + // for code size. + + writer.WriteLine("public static {0} ParseFrom(pb::ByteString data) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(byte[] data) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(global::System.IO.Stream input) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(pb::CodedInputStream input) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();"); + writer.WriteLine("}"); + writer.WriteLine("public static {0} ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {{", ClassName); + writer.WriteLine(" return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();"); + writer.WriteLine("}"); + } + + /// <summary> + /// Returns whether or not the specified message type has any required fields. + /// If it doesn't, calls to check for initialization can be optimised. + /// TODO(jonskeet): Move this into MessageDescriptor? + /// </summary> + private static bool HasRequiredFields(MessageDescriptor descriptor, Dictionary<MessageDescriptor,object> alreadySeen) { + if (alreadySeen.ContainsKey(descriptor)) { + // The type is already in cache. This means that either: + // a. The type has no required fields. + // b. We are in the midst of checking if the type has required fields, + // somewhere up the stack. In this case, we know that if the type + // has any required fields, they'll be found when we return to it, + // and the whole call to HasRequiredFields() will return true. + // Therefore, we don't have to check if this type has required fields + // here. + return false; + } + alreadySeen[descriptor] = descriptor; // Value is irrelevant + + // If the type has extensions, an extension with message type could contain + // required fields, so we have to be conservative and assume such an + // extension exists. + if (descriptor.Extensions.Count > 0) { + return true; + } + + foreach (FieldDescriptor field in descriptor.Fields) { + if (field.IsRequired) { + return true; + } + // Message or group + if (field.MappedType == MappedType.Message) { + if (HasRequiredFields(field.MessageType, alreadySeen)) { + return true; + } + } + } + return false; + } + + private void GenerateBuilder(TextGenerator writer) { + writer.WriteLine("public static Builder CreateBuilder() { return new Builder(); }"); + writer.WriteLine("public override Builder CreateBuilderForType() { return new Builder(); }"); + writer.WriteLine("public static Builder CreateBuilder({0} prototype) {{", ClassName); + writer.WriteLine(" return (Builder) new Builder().MergeFrom(prototype);"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("{0} sealed partial class Builder : pb::{2}Builder<{1}, Builder> {{", + ClassAccessLevel, ClassName, Descriptor.Proto.ExtensionRangeCount > 0 ? "Extendable" : "Generated"); + writer.Indent(); + writer.WriteLine("protected override Builder ThisBuilder {"); + writer.WriteLine(" get { return this; }"); + writer.WriteLine("}"); + GenerateCommonBuilderMethods(writer); + if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) { + GenerateBuilderParsingMethods(writer); + } + foreach (FieldDescriptor field in Descriptor.Fields) { + writer.WriteLine(); + // No field comment :( + SourceGenerators.CreateFieldGenerator(field).GenerateBuilderMembers(writer); + } + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + + private void GenerateCommonBuilderMethods(TextGenerator writer) { + writer.WriteLine("{0} Builder() {{}}", ClassAccessLevel); + writer.WriteLine(); + writer.WriteLine("{0} result = new {0}();", ClassName); + writer.WriteLine(); + writer.WriteLine("protected override {0} MessageBeingBuilt {{", ClassName); + writer.WriteLine(" get { return result; }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override Builder Clear() {"); + writer.WriteLine(" result = new {0}();", ClassName); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override Builder Clone() {"); + writer.WriteLine(" return new Builder().MergeFrom(result);"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override pbd::MessageDescriptor DescriptorForType {"); + writer.WriteLine(" get {{ return {0}.Descriptor; }}", ClassName); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override {0} DefaultInstanceForType {{", ClassName); + writer.WriteLine(" get {{ return {0}.DefaultInstance; }}", ClassName); + writer.WriteLine("}"); + writer.WriteLine(); + + writer.WriteLine("public override {0} BuildPartial() {{", ClassName); + writer.Indent(); + foreach (FieldDescriptor field in Descriptor.Fields) { + SourceGenerators.CreateFieldGenerator(field).GenerateBuildingCode(writer); + } + writer.WriteLine("{0} returnMe = result;", ClassName); + writer.WriteLine("result = null;"); + writer.WriteLine("return returnMe;"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + + if (Descriptor.File.Options.OptimizeFor == FileOptions.Types.OptimizeMode.SPEED) { + writer.WriteLine("public override Builder MergeFrom(pb::IMessage other) {"); + writer.WriteLine(" if (other is {0}) {{", ClassName); + writer.WriteLine(" return MergeFrom(({0}) other);", ClassName); + writer.WriteLine(" } else {"); + writer.WriteLine(" base.MergeFrom(other);"); + writer.WriteLine(" return this;"); + writer.WriteLine(" }"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override Builder MergeFrom({0} other) {{", ClassName); + // Optimization: If other is the default instance, we know none of its + // fields are set so we can skip the merge. + writer.Indent(); + writer.WriteLine("if (other == {0}.DefaultInstance) return this;", ClassName); + foreach (FieldDescriptor field in Descriptor.Fields) { + SourceGenerators.CreateFieldGenerator(field).GenerateMergingCode(writer); + } + writer.WriteLine("this.MergeUnknownFields(other.UnknownFields);"); + writer.WriteLine("return this;"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + } + + private void GenerateBuilderParsingMethods(TextGenerator writer) { + List<FieldDescriptor> sortedFields = new List<FieldDescriptor>(Descriptor.Fields); + sortedFields.Sort((f1, f2) => f1.FieldNumber.CompareTo(f2.FieldNumber)); + + writer.WriteLine("public override Builder MergeFrom(pb::CodedInputStream input) {"); + writer.WriteLine(" return MergeFrom(input, pb::ExtensionRegistry.Empty);"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {"); + writer.Indent(); + writer.WriteLine("pb::UnknownFieldSet.Builder unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);"); + writer.WriteLine("while (true) {"); + writer.Indent(); + writer.WriteLine("uint tag = input.ReadTag();"); + writer.WriteLine("switch (tag) {"); + writer.Indent(); + writer.WriteLine("case 0: {"); // 0 signals EOF / limit reached + writer.WriteLine(" this.UnknownFields = unknownFields.Build();"); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("default: {"); + writer.WriteLine(" if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) {"); + writer.WriteLine(" this.UnknownFields = unknownFields.Build();"); + writer.WriteLine(" return this;"); // it's an endgroup tag + writer.WriteLine(" }"); + writer.WriteLine(" break;"); + writer.WriteLine("}"); + foreach (FieldDescriptor field in sortedFields) { + uint tag = WireFormat.MakeTag(field.FieldNumber, WireFormat.GetWireType(field.FieldType)); + writer.WriteLine("case {0}: {{", tag); + writer.Indent(); + SourceGenerators.CreateFieldGenerator(field).GenerateParsingCode(writer); + writer.WriteLine("break;"); + writer.Outdent(); + writer.WriteLine("}"); + } + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + + private void GenerateIsInitialized(TextGenerator writer) { + writer.WriteLine("public override bool IsInitialized {"); + writer.Indent(); + writer.WriteLine("get {"); + writer.Indent(); + + // Check that all required fields in this message are set. + // TODO(kenton): We can optimize this when we switch to putting all the + // "has" fields into a single bitfield. + foreach (FieldDescriptor field in Descriptor.Fields) { + if (field.IsRequired) { + writer.WriteLine("if (!has{0}) return false;", Helpers.UnderscoresToPascalCase(field.Name)); + } + } + + // Now check that all embedded messages are initialized. + foreach (FieldDescriptor field in Descriptor.Fields) { + if (field.FieldType != FieldType.Message || + !HasRequiredFields(field.MessageType, new Dictionary<MessageDescriptor, object>())) { + continue; + } + string propertyName = Helpers.UnderscoresToPascalCase(DescriptorUtil.GetFieldName(field)); + if (field.IsRepeated) { + writer.WriteLine("foreach ({0} element in {1}List) {{", DescriptorUtil.GetClassName(field.MessageType), propertyName); + writer.WriteLine(" if (!element.IsInitialized) return false;"); + writer.WriteLine("}"); + } else if (field.IsOptional) { + writer.WriteLine("if (Has{0}) {{", propertyName); + writer.WriteLine(" if (!{0}.IsInitialized) return false;", propertyName); + writer.WriteLine("}"); + } else { + writer.WriteLine("if (!{0}.IsInitialized) return false;", propertyName); + } + } + + if (Descriptor.Proto.ExtensionRangeCount > 0) { + writer.WriteLine("if (!ExtensionsAreInitialized) return false;"); + } + writer.WriteLine("return true;"); + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + } +} diff --git a/src/ProtoGen/PrimitiveFieldGenerator.cs b/src/ProtoGen/PrimitiveFieldGenerator.cs new file mode 100644 index 00000000..9107def9 --- /dev/null +++ b/src/ProtoGen/PrimitiveFieldGenerator.cs @@ -0,0 +1,70 @@ +using System; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + // TODO(jonskeet): Refactor this. There's loads of common code here. + internal class PrimitiveFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator { + + internal PrimitiveFieldGenerator(FieldDescriptor descriptor) + : base(descriptor) { + } + + public void GenerateMembers(TextGenerator writer) { + writer.WriteLine("private bool has{0};", CapitalizedName); + writer.WriteLine("private {0} {1}_ = {2};", TypeName, Name, DefaultValue); + writer.WriteLine("public bool Has{0} {{", CapitalizedName); + writer.WriteLine(" get {{ return has{0}; }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public {0} {1} {{", TypeName, PropertyName); + writer.WriteLine(" get {{ return {0}_; }}", Name); + writer.WriteLine("}"); + } + + public void GenerateBuilderMembers(TextGenerator writer) { + writer.WriteLine("public bool Has{0} {{", CapitalizedName); + writer.WriteLine(" get {{ return result.Has{0}; }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public {0} {1} {{", TypeName, PropertyName); + writer.WriteLine(" get {{ return result.{0}; }}", PropertyName); + writer.WriteLine(" set {{ Set{0}(value); }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public Builder Set{0}({1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.has{0} = true;", CapitalizedName); + writer.WriteLine(" result.{0}_ = value;", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName); + writer.WriteLine(" result.has{0} = false;", CapitalizedName); + writer.WriteLine(" result.{0}_ = {1};", Name, DefaultValue); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + } + + public void GenerateMergingCode(TextGenerator writer) { + writer.WriteLine("if (other.Has{0}) {{", CapitalizedName); + writer.WriteLine(" {0} = other.{0};", PropertyName); + writer.WriteLine("}"); + } + + public void GenerateBuildingCode(TextGenerator writer) { + // Nothing to do here for primitive types + } + + public void GenerateParsingCode(TextGenerator writer) { + writer.WriteLine("{0} = input.Read{1}();", PropertyName, CapitalizedTypeName); + } + + public void GenerateSerializationCode(TextGenerator writer) { + writer.WriteLine("if (Has{0}) {{", CapitalizedName); + writer.WriteLine(" output.Write{0}({1}, {2});", CapitalizedTypeName, Number, PropertyName); + writer.WriteLine("}"); + } + + public void GenerateSerializedSizeCode(TextGenerator writer) { + writer.WriteLine("if (Has{0}) {{", CapitalizedName); + writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, {2});", + CapitalizedTypeName, Number, PropertyName); + writer.WriteLine("}"); + } + } +} diff --git a/src/ProtoGen/Program.cs b/src/ProtoGen/Program.cs new file mode 100644 index 00000000..08cad358 --- /dev/null +++ b/src/ProtoGen/Program.cs @@ -0,0 +1,47 @@ +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.ProtoGen { + /// <summary> + /// Entry point for the Protocol Buffers generator. + /// </summary> + class Program { + static int Main(string[] args) { + try { + // Hack to make sure everything's initialized + DescriptorProtoFile.Descriptor.ToString(); + GeneratorOptions options = ParseCommandLineArguments(args); + + IList<string> validationFailures; + if (!options.TryValidate(out validationFailures)) { + // We've already got the message-building logic in the exception... + InvalidOptionsException exception = new InvalidOptionsException(validationFailures); + Console.WriteLine(exception.Message); + return 1; + } + + Generator generator = Generator.CreateGenerator(options); + generator.Generate(); + + + return 0; + } catch (Exception e) { + Console.Error.WriteLine("Error: {0}", e.Message); + Console.Error.WriteLine(); + Console.Error.WriteLine("Detailed exception information: {0}", e); + return 1; + } + } + + private static GeneratorOptions ParseCommandLineArguments(string[] args) { + GeneratorOptions options = new GeneratorOptions(); + //string baseDir = "c:\\Users\\Jon\\Documents\\Visual Studio 2008\\Projects\\ProtocolBuffers"; + //options.OutputDirectory = baseDir + "\\tmp"; + //options.InputFiles = new[] { baseDir + "\\protos\\nwind-solo.protobin" }; + options.OutputDirectory = "."; + options.InputFiles = args; + return options; + } + } +}
\ No newline at end of file diff --git a/src/ProtoGen/Properties/AssemblyInfo.cs b/src/ProtoGen/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..24f5d781 --- /dev/null +++ b/src/ProtoGen/Properties/AssemblyInfo.cs @@ -0,0 +1,42 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtoGen")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtoGen")] +[assembly: AssemblyCopyright("Copyright © 2008")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("7101763b-7a38-41be-87f5-7ede4c554509")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: InternalsVisibleTo("Google.ProtocolBuffers.ProtoGen.Test,PublicKey=" + +"0024000004800000940000000602000000240000525341310004000001000100cf43741ffc3e65" + +"c85707245e144e90f1bb82f20d1b1555846008d4d5d5c9270a980350dcb1ddd40fcdde13c2780c" + +"75c9057123daa5613cb6551e2b8bd2254e8f84b3893369869e5119b752442aef7156c4defc489b" + +"96c44ff801fe8d94199e048f8ff414813c9c811a029bcd697040700dc66982539e9b368cb5e725" + +"feed60f2")] diff --git a/src/ProtoGen/Properties/Google.ProtocolBuffers.ProtoGen.snk b/src/ProtoGen/Properties/Google.ProtocolBuffers.ProtoGen.snk Binary files differnew file mode 100644 index 00000000..8e4d98a5 --- /dev/null +++ b/src/ProtoGen/Properties/Google.ProtocolBuffers.ProtoGen.snk diff --git a/src/ProtoGen/ProtoGen.csproj b/src/ProtoGen/ProtoGen.csproj new file mode 100644 index 00000000..f48df42c --- /dev/null +++ b/src/ProtoGen/ProtoGen.csproj @@ -0,0 +1,85 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProductVersion>9.0.30729</ProductVersion> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{250ADE34-82FD-4BAE-86D5-985FBE589C4A}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>Google.ProtocolBuffers.ProtoGen</RootNamespace> + <AssemblyName>ProtoGen</AssemblyName> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + <TargetFrameworkSubset> + </TargetFrameworkSubset> + <SignAssembly>true</SignAssembly> + <AssemblyOriginatorKeyFile>Properties\Google.ProtocolBuffers.ProtoGen.snk</AssemblyOriginatorKeyFile> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <ItemGroup> + <Reference Include="System" /> + </ItemGroup> + <ItemGroup> + <Compile Include="DescriptorUtil.cs" /> + <Compile Include="EnumFieldGenerator.cs" /> + <Compile Include="EnumGenerator.cs" /> + <Compile Include="ExtensionGenerator.cs" /> + <Compile Include="FieldGeneratorBase.cs" /> + <Compile Include="IFieldSourceGenerator.cs" /> + <Compile Include="ISourceGenerator.cs" /> + <Compile Include="MessageFieldGenerator.cs" /> + <Compile Include="MessageGenerator.cs" /> + <Compile Include="PrimitiveFieldGenerator.cs" /> + <Compile Include="RepeatedEnumFieldGenerator.cs" /> + <Compile Include="RepeatedMessageFieldGenerator.cs" /> + <Compile Include="RepeatedPrimitiveFieldGenerator.cs" /> + <Compile Include="ServiceGenerator.cs" /> + <Compile Include="SourceFileGenerator.cs" /> + <Compile Include="DependencyResolutionException.cs" /> + <Compile Include="Generator.cs" /> + <Compile Include="GeneratorOptions.cs" /> + <Compile Include="Helpers.cs" /> + <Compile Include="InvalidOptionsException.cs" /> + <Compile Include="Program.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + <Compile Include="SourceGeneratorBase.cs" /> + <Compile Include="SourceGenerators.cs" /> + <Compile Include="UmbrellaClassGenerator.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="app.config" /> + <None Include="Properties\Google.ProtocolBuffers.ProtoGen.snk" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj"> + <Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project> + <Name>ProtocolBuffers</Name> + </ProjectReference> + </ItemGroup> + <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> + <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + --> +</Project>
\ No newline at end of file diff --git a/src/ProtoGen/RepeatedEnumFieldGenerator.cs b/src/ProtoGen/RepeatedEnumFieldGenerator.cs new file mode 100644 index 00000000..3a988fbc --- /dev/null +++ b/src/ProtoGen/RepeatedEnumFieldGenerator.cs @@ -0,0 +1,90 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class RepeatedEnumFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator { + + internal RepeatedEnumFieldGenerator(FieldDescriptor descriptor) + : base(descriptor) { + } + + public void GenerateMembers(TextGenerator writer) { + writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name); + writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName); + writer.WriteLine(" get {{ return pbc::Lists.AsReadOnly({0}_); }}", Name); + writer.WriteLine("}"); + + // TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option. + writer.WriteLine("public int {0}Count {{", CapitalizedName); + writer.WriteLine(" get {{ return {0}_.Count; }}", Name); + writer.WriteLine("}"); + + writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName); + writer.WriteLine(" return {0}_[index];", Name); + writer.WriteLine("}"); + } + + public void GenerateBuilderMembers(TextGenerator writer) { + // Note: We can return the original list here, because we make it unmodifiable when we build + writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName); + writer.WriteLine(" get {{ return result.{0}_; }}", Name); + writer.WriteLine("}"); + writer.WriteLine("public int {0}Count {{", CapitalizedName); + writer.WriteLine(" get {{ return result.{0}Count; }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName); + writer.WriteLine(" return result.Get{0}(index);", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.{0}_[index] = value;", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Add{0}({1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.{0}_.Add(value);", Name, TypeName); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", CapitalizedName, TypeName); + writer.WriteLine(" base.AddRange(values, result.{0}_);", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName); + writer.WriteLine(" result.{0}_.Clear();", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + } + + public void GenerateMergingCode(TextGenerator writer) { + writer.WriteLine("if (other.{0}_.Count != 0) {{", Name); + writer.WriteLine(" base.AddRange(other.{0}_, result.{0}_);", Name); + writer.WriteLine("}"); + } + + public void GenerateBuildingCode(TextGenerator writer) { + writer.WriteLine("result.{0}_.MakeReadOnly();", Name); + } + + public void GenerateParsingCode(TextGenerator writer) { + // TODO(jonskeet): Make a more efficient way of doing this + writer.WriteLine("int rawValue = input.ReadEnum();"); + writer.WriteLine("if (!global::System.Enum.IsDefined(typeof({0}), rawValue)) {{", TypeName); + writer.WriteLine(" unknownFields.MergeVarintField({0}, (ulong) rawValue);", Number); + writer.WriteLine("} else {"); + writer.WriteLine(" Add{0}(({1}) rawValue);", CapitalizedName, TypeName); + writer.WriteLine("}"); + } + + public void GenerateSerializationCode(TextGenerator writer) { + writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName); + writer.WriteLine(" output.WriteEnum({0}, (int) element);", Number); + writer.WriteLine("}"); + } + + public void GenerateSerializedSizeCode(TextGenerator writer) { + writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName); + writer.WriteLine(" size += pb::CodedOutputStream.ComputeEnumSize({0}, (int) element);", Number); + writer.WriteLine("}"); + } + } +} diff --git a/src/ProtoGen/RepeatedMessageFieldGenerator.cs b/src/ProtoGen/RepeatedMessageFieldGenerator.cs new file mode 100644 index 00000000..08d574a9 --- /dev/null +++ b/src/ProtoGen/RepeatedMessageFieldGenerator.cs @@ -0,0 +1,100 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class RepeatedMessageFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator { + + internal RepeatedMessageFieldGenerator(FieldDescriptor descriptor) + : base(descriptor) { + } + + public void GenerateMembers(TextGenerator writer) { + writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name); + writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName); + writer.WriteLine(" get {{ return {0}_; }}", Name); + writer.WriteLine("}"); + + // TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option. + writer.WriteLine("public int {0}Count {{", CapitalizedName); + writer.WriteLine(" get {{ return {0}_.Count; }}", Name); + writer.WriteLine("}"); + + writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName); + writer.WriteLine(" return {0}_[index];", Name); + writer.WriteLine("}"); + } + + public void GenerateBuilderMembers(TextGenerator writer) { + // Note: We can return the original list here, because we make it unmodifiable when we build + writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName); + writer.WriteLine(" get {{ return result.{0}_; }}", Name); + writer.WriteLine("}"); + writer.WriteLine("public int {0}Count {{", CapitalizedName); + writer.WriteLine(" get {{ return result.{0}Count; }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName); + writer.WriteLine(" return result.Get{0}(index);", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.{0}_[index] = value;", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + // Extra overload for builder (just on messages) + writer.WriteLine("public Builder Set{0}(int index, {1}.Builder builderForValue) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.{0}_[index] = builderForValue.Build();", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Add{0}({1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.{0}_.Add(value);", Name, TypeName); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + // Extra overload for builder (just on messages) + writer.WriteLine("public Builder Add{0}({1}.Builder builderForValue) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.{0}_.Add(builderForValue.Build());", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", CapitalizedName, TypeName); + writer.WriteLine(" base.AddRange(values, result.{0}_);", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName); + writer.WriteLine(" result.{0}_.Clear();", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + } + + public void GenerateMergingCode(TextGenerator writer) { + writer.WriteLine("if (other.{0}_.Count != 0) {{", Name); + writer.WriteLine(" base.AddRange(other.{0}_, result.{0}_);", Name); + writer.WriteLine("}"); + } + + public void GenerateBuildingCode(TextGenerator writer) { + writer.WriteLine("result.{0}_.MakeReadOnly();", Name); + } + + public void GenerateParsingCode(TextGenerator writer) { + writer.WriteLine("{0}.Builder subBuilder = {0}.CreateBuilder();", TypeName); + if (Descriptor.FieldType == FieldType.Group) { + writer.WriteLine("input.ReadGroup({0}, subBuilder, extensionRegistry);", Number); + } else { + writer.WriteLine("input.ReadMessage(subBuilder, extensionRegistry);"); + } + writer.WriteLine("Add{0}(subBuilder.BuildPartial());", CapitalizedName); + } + + public void GenerateSerializationCode(TextGenerator writer) { + writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName); + writer.WriteLine(" output.Write{0}({1}, element);", MessageOrGroup, Number); + writer.WriteLine("}"); + } + + public void GenerateSerializedSizeCode(TextGenerator writer) { + writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName); + writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, element);", MessageOrGroup, Number); + writer.WriteLine("}"); + } + } +} diff --git a/src/ProtoGen/RepeatedPrimitiveFieldGenerator.cs b/src/ProtoGen/RepeatedPrimitiveFieldGenerator.cs new file mode 100644 index 00000000..cdb7cd6f --- /dev/null +++ b/src/ProtoGen/RepeatedPrimitiveFieldGenerator.cs @@ -0,0 +1,84 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class RepeatedPrimitiveFieldGenerator : FieldGeneratorBase, IFieldSourceGenerator { + + internal RepeatedPrimitiveFieldGenerator(FieldDescriptor descriptor) + : base(descriptor) { + } + + public void GenerateMembers(TextGenerator writer) { + writer.WriteLine("private pbc::PopsicleList<{0}> {1}_ = new pbc::PopsicleList<{0}>();", TypeName, Name); + writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName); + writer.WriteLine(" get {{ return pbc::Lists.AsReadOnly({0}_); }}", Name); + writer.WriteLine("}"); + + // TODO(jonskeet): Redundant API calls? Possibly - include for portability though. Maybe create an option. + writer.WriteLine("public int {0}Count {{", CapitalizedName); + writer.WriteLine(" get {{ return {0}_.Count; }}", Name); + writer.WriteLine("}"); + + writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName); + writer.WriteLine(" return {0}_[index];", Name); + writer.WriteLine("}"); + } + + public void GenerateBuilderMembers(TextGenerator writer) { + // Note: We can return the original list here, because we make it unmodifiable when we build + writer.WriteLine("public scg::IList<{0}> {1}List {{", TypeName, CapitalizedName); + writer.WriteLine(" get {{ return result.{0}_; }}", Name); + writer.WriteLine("}"); + writer.WriteLine("public int {0}Count {{", CapitalizedName); + writer.WriteLine(" get {{ return result.{0}Count; }}", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public {0} Get{1}(int index) {{", TypeName, CapitalizedName); + writer.WriteLine(" return result.Get{0}(index);", CapitalizedName); + writer.WriteLine("}"); + writer.WriteLine("public Builder Set{0}(int index, {1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.{0}_[index] = value;", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Add{0}({1} value) {{", CapitalizedName, TypeName); + writer.WriteLine(" result.{0}_.Add(value);", Name, TypeName); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder AddRange{0}(scg::IEnumerable<{1}> values) {{", CapitalizedName, TypeName); + writer.WriteLine(" base.AddRange(values, result.{0}_);", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + writer.WriteLine("public Builder Clear{0}() {{", CapitalizedName); + writer.WriteLine(" result.{0}_.Clear();", Name); + writer.WriteLine(" return this;"); + writer.WriteLine("}"); + } + + public void GenerateMergingCode(TextGenerator writer) { + writer.WriteLine("if (other.{0}_.Count != 0) {{", Name); + writer.WriteLine(" base.AddRange(other.{0}_, result.{0}_);", Name); + writer.WriteLine("}"); + } + + public void GenerateBuildingCode(TextGenerator writer) { + writer.WriteLine("result.{0}_.MakeReadOnly();", Name); + } + + public void GenerateParsingCode(TextGenerator writer) { + writer.WriteLine("Add{0}(input.Read{1}());", CapitalizedName, CapitalizedTypeName); + } + + public void GenerateSerializationCode(TextGenerator writer) { + writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName); + writer.WriteLine(" output.Write{0}({1}, element);", CapitalizedTypeName, Number); + writer.WriteLine("}"); + } + + public void GenerateSerializedSizeCode(TextGenerator writer) { + writer.WriteLine("foreach ({0} element in {1}List) {{", TypeName, CapitalizedName); + writer.WriteLine(" size += pb::CodedOutputStream.Compute{0}Size({1}, element);", CapitalizedTypeName, Number); + writer.WriteLine("}"); + } + } +} diff --git a/src/ProtoGen/ServiceGenerator.cs b/src/ProtoGen/ServiceGenerator.cs new file mode 100644 index 00000000..089172db --- /dev/null +++ b/src/ProtoGen/ServiceGenerator.cs @@ -0,0 +1,138 @@ +using System; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal class ServiceGenerator : SourceGeneratorBase<ServiceDescriptor>, ISourceGenerator { + + private enum RequestOrResponse { + Request, + Response + } + + internal ServiceGenerator(ServiceDescriptor descriptor) + : base(descriptor) { + } + + public void Generate(TextGenerator writer) { + writer.WriteLine("{0} abstract class {1} : pb::IService {{", ClassAccessLevel, Descriptor.Name); + writer.Indent(); + + foreach (MethodDescriptor method in Descriptor.Methods) { + writer.WriteLine("{0} abstract void {1}(", ClassAccessLevel, Helpers.UnderscoresToPascalCase(method.Name)); + writer.WriteLine(" pb::IRpcController controller,"); + writer.WriteLine(" {0} request,", DescriptorUtil.GetClassName(method.InputType)); + writer.WriteLine(" global::System.Action<{0}> done);", DescriptorUtil.GetClassName(method.OutputType)); + } + + // Generate Descriptor and DescriptorForType. + writer.WriteLine(); + writer.WriteLine("{0} static pbd::ServiceDescriptor Descriptor {{", ClassAccessLevel); + writer.WriteLine(" get {{ return {0}.Descriptor.Services[{1}]; }}", + DescriptorUtil.GetUmbrellaClassName(Descriptor.File), Descriptor.Index); + writer.WriteLine("}"); + writer.WriteLine("{0} pbd::ServiceDescriptor DescriptorForType {{", ClassAccessLevel); + writer.WriteLine(" get { return Descriptor; }"); + writer.WriteLine("}"); + + GenerateCallMethod(writer); + GenerateGetPrototype(RequestOrResponse.Request, writer); + GenerateGetPrototype(RequestOrResponse.Response, writer); + GenerateStub(writer); + + writer.Outdent(); + writer.WriteLine("}"); + } + + private void GenerateCallMethod(TextGenerator writer) { + writer.WriteLine(); + writer.WriteLine("public void CallMethod(", ClassAccessLevel); + writer.WriteLine(" pbd::MethodDescriptor method,"); + writer.WriteLine(" pb::IRpcController controller,"); + writer.WriteLine(" pb::IMessage request,"); + writer.WriteLine(" global::System.Action<pb::IMessage> done) {"); + writer.Indent(); + writer.WriteLine("if (method.Service != Descriptor) {"); + writer.WriteLine(" throw new global::System.ArgumentException("); + writer.WriteLine(" \"Service.CallMethod() given method descriptor for wrong service type.\");"); + writer.WriteLine("}"); + writer.WriteLine("switch(method.Index) {"); + writer.Indent(); + foreach (MethodDescriptor method in Descriptor.Methods) { + writer.WriteLine("case {0}:", method.Index); + writer.WriteLine(" this.{0}(controller, ({1}) request,", + Helpers.UnderscoresToPascalCase(method.Name), DescriptorUtil.GetClassName(method.InputType)); + writer.WriteLine(" pb::RpcUtil.SpecializeCallback<{0}>(", DescriptorUtil.GetClassName(method.OutputType)); + writer.WriteLine(" done));"); + writer.WriteLine(" return;"); + } + writer.WriteLine("default:"); + writer.WriteLine(" throw new global::System.InvalidOperationException(\"Can't get here.\");"); + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + + private void GenerateGetPrototype(RequestOrResponse which, TextGenerator writer) { + writer.WriteLine("public pb::IMessage Get{0}Prototype(pbd::MethodDescriptor method) {{", which); + writer.Indent(); + writer.WriteLine("if (method.Service != Descriptor) {"); + writer.WriteLine(" throw new global::System.ArgumentException("); + writer.WriteLine(" \"Service.Get{0}Prototype() given method descriptor for wrong service type.\");", which); + writer.WriteLine("}"); + writer.WriteLine("switch(method.Index) {"); + writer.Indent(); + + foreach (MethodDescriptor method in Descriptor.Methods) { + writer.WriteLine("case {0}:", method.Index); + writer.WriteLine(" return {0}.DefaultInstance;", + DescriptorUtil.GetClassName(which == RequestOrResponse.Request ? method.InputType : method.OutputType)); + } + writer.WriteLine("default:"); + writer.WriteLine(" throw new global::System.InvalidOperationException(\"Can't get here.\");"); + writer.Outdent(); + writer.WriteLine("}"); + writer.Outdent(); + writer.WriteLine("}"); + writer.WriteLine(); + } + + private void GenerateStub(TextGenerator writer) { + writer.WriteLine("public static Stub CreateStub(pb::IRpcChannel channel) {"); + writer.WriteLine(" return new Stub(channel);"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("{0} class Stub : {1} {{", ClassAccessLevel, DescriptorUtil.GetClassName(Descriptor)); + writer.Indent(); + writer.WriteLine("internal Stub(pb::IRpcChannel channel) {"); + writer.WriteLine(" this.channel = channel;"); + writer.WriteLine("}"); + writer.WriteLine(); + writer.WriteLine("private readonly pb::IRpcChannel channel;"); + writer.WriteLine(); + writer.WriteLine("public pb::IRpcChannel Channel {"); + writer.WriteLine(" get { return channel; }"); + writer.WriteLine("}"); + + foreach (MethodDescriptor method in Descriptor.Methods) { + writer.WriteLine(); + writer.WriteLine("public override void {0}(", Helpers.UnderscoresToPascalCase(method.Name)); + writer.WriteLine(" pb::IRpcController controller,"); + writer.WriteLine(" {0} request,", DescriptorUtil.GetClassName(method.InputType)); + writer.WriteLine(" global::System.Action<{0}> done) {{", DescriptorUtil.GetClassName(method.OutputType)); + writer.Indent(); + writer.WriteLine("channel.CallMethod(Descriptor.Methods[{0}],", method.Index); + writer.WriteLine(" controller, request, {0}.DefaultInstance,", DescriptorUtil.GetClassName(method.OutputType)); + writer.WriteLine(" pb::RpcUtil.GeneralizeCallback<{0}, {0}.Builder>(done, {0}.DefaultInstance));", + DescriptorUtil.GetClassName(method.OutputType)); + writer.Outdent(); + writer.WriteLine("}"); + } + writer.Outdent(); + writer.WriteLine("}"); + } + } +} diff --git a/src/ProtoGen/SourceFileGenerator.cs b/src/ProtoGen/SourceFileGenerator.cs new file mode 100644 index 00000000..1984d297 --- /dev/null +++ b/src/ProtoGen/SourceFileGenerator.cs @@ -0,0 +1,29 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + /// <summary> + /// Generator to hold a TextGenerator, generate namespace aliases etc. + /// Each source file created uses one of these, and it can be used to create + /// multiple classes within the same file. + /// </summary> + internal class SourceFileGenerator { + + private readonly TextGenerator output; + + private SourceFileGenerator(TextWriter writer) { + output = new TextGenerator(writer); + } + + /// <summary> + /// Creates a ClassFileGenerator for the given writer, which will be closed + /// when the instance is disposed. The specified namespace is created, if it's non-null. + /// </summary> + internal static SourceFileGenerator ForWriter(TextWriter writer) { + return new SourceFileGenerator(writer); + } + } +} diff --git a/src/ProtoGen/SourceGeneratorBase.cs b/src/ProtoGen/SourceGeneratorBase.cs new file mode 100644 index 00000000..563c64a1 --- /dev/null +++ b/src/ProtoGen/SourceGeneratorBase.cs @@ -0,0 +1,50 @@ +using System.Collections.Generic; +using Google.ProtocolBuffers.DescriptorProtos; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal abstract class SourceGeneratorBase<T> where T : IDescriptor { + + private readonly T descriptor; + + protected SourceGeneratorBase(T descriptor) { + this.descriptor = descriptor; + } + + protected T Descriptor { + get { return descriptor; } + } + + protected string ClassAccessLevel { + get { + // Default to public + return !descriptor.File.Options.HasExtension(CSharpOptions.CSharpPublicClasses) + || descriptor.File.Options.GetExtension(CSharpOptions.CSharpPublicClasses) ? "public" : "internal"; + } + } + + public bool MultipleFiles { + get { return descriptor.File.Options.GetExtension(CSharpOptions.CSharpMultipleFiles); } + } + + protected static void WriteChildren<TChild>(TextGenerator writer, string region, IEnumerable<TChild> children) + where TChild : IDescriptor { + // Copy the set of children; makes access easier + List<TChild> copy = new List<TChild>(children); + if (copy.Count == 0) { + return; + } + + if (region != null) { + writer.WriteLine("#region {0}", region); + } + foreach (TChild child in children) { + SourceGenerators.CreateGenerator(child).Generate(writer); + } + if (region != null) { + writer.WriteLine("#endregion"); + writer.WriteLine(); + } + } + } +} diff --git a/src/ProtoGen/SourceGenerators.cs b/src/ProtoGen/SourceGenerators.cs new file mode 100644 index 00000000..c775e419 --- /dev/null +++ b/src/ProtoGen/SourceGenerators.cs @@ -0,0 +1,42 @@ +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + internal static class SourceGenerators { + + private static readonly Dictionary<Type, Func<IDescriptor, ISourceGenerator>> GeneratorFactories = new Dictionary<Type, Func<IDescriptor, ISourceGenerator>> { + { typeof(FileDescriptor), descriptor => new UmbrellaClassGenerator((FileDescriptor) descriptor) }, + { typeof(EnumDescriptor), descriptor => new EnumGenerator((EnumDescriptor) descriptor) }, + { typeof(ServiceDescriptor), descriptor => new ServiceGenerator((ServiceDescriptor) descriptor) }, + { typeof(MessageDescriptor), descriptor => new MessageGenerator((MessageDescriptor) descriptor) }, + // For other fields, we have IFieldSourceGenerators. + { typeof(FieldDescriptor), descriptor => new ExtensionGenerator((FieldDescriptor) descriptor) } + }; + + public static IFieldSourceGenerator CreateFieldGenerator(FieldDescriptor field) { + switch (field.MappedType) { + case MappedType.Message : + return field.IsRepeated + ? (IFieldSourceGenerator) new RepeatedMessageFieldGenerator(field) + : new MessageFieldGenerator(field); + case MappedType.Enum: + return field.IsRepeated + ? (IFieldSourceGenerator)new RepeatedEnumFieldGenerator(field) + : new EnumFieldGenerator(field); + default: + return field.IsRepeated + ? (IFieldSourceGenerator)new RepeatedPrimitiveFieldGenerator(field) + : new PrimitiveFieldGenerator(field); + } + } + + public static ISourceGenerator CreateGenerator<T>(T descriptor) where T : IDescriptor { + Func<IDescriptor, ISourceGenerator> factory; + if (!GeneratorFactories.TryGetValue(typeof(T), out factory)) { + throw new ArgumentException("No generator registered for " + typeof(T).Name); + } + return factory(descriptor); + } + } +} diff --git a/src/ProtoGen/UmbrellaClassGenerator.cs b/src/ProtoGen/UmbrellaClassGenerator.cs new file mode 100644 index 00000000..7db5c46c --- /dev/null +++ b/src/ProtoGen/UmbrellaClassGenerator.cs @@ -0,0 +1,96 @@ +using System; +using Google.ProtocolBuffers.DescriptorProtos; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.ProtoGen { + /// <summary> + /// Generator for the class describing the .proto file in general, + /// containing things like the message descriptor. + /// </summary> + internal sealed class UmbrellaClassGenerator : SourceGeneratorBase<FileDescriptor>, ISourceGenerator { + + internal UmbrellaClassGenerator(FileDescriptor descriptor) + : base(descriptor) { + } + + public void Generate(TextGenerator writer) { + WriteIntroduction(writer); + WriteDescriptor(writer); + WriteChildren(writer, "Extensions", Descriptor.Extensions); + writer.WriteLine("#region Static variables"); + foreach (MessageDescriptor message in Descriptor.MessageTypes) { + new MessageGenerator(message).GenerateStaticVariables(writer); + } + writer.WriteLine("#endregion"); + // The class declaration either gets closed before or after the children are written. + if (!DescriptorUtil.NestClasses(Descriptor)) { + writer.Outdent(); + writer.WriteLine("}"); + } + WriteChildren(writer, "Enums", Descriptor.EnumTypes); + WriteChildren(writer, "Messages", Descriptor.MessageTypes); + WriteChildren(writer, "Services", Descriptor.Services); + if (DescriptorUtil.NestClasses(Descriptor)) { + writer.Outdent(); + writer.WriteLine("}"); + } + if (DescriptorUtil.GetNamespace(Descriptor) != "") { + writer.Outdent(); + writer.WriteLine("}"); + } + } + + private void WriteIntroduction(TextGenerator writer) { + writer.WriteLine("// Generated by the protocol buffer compiler. DO NOT EDIT!"); + writer.WriteLine(); + Helpers.WriteNamespaces(writer); + + if (DescriptorUtil.GetNamespace(Descriptor) != "") { + writer.WriteLine("namespace {0} {{", DescriptorUtil.GetNamespace(Descriptor)); + writer.Indent(); + writer.WriteLine(); + } + + writer.WriteLine("{0} static partial class {1} {{", ClassAccessLevel, DescriptorUtil.GetUmbrellaClassName(Descriptor)); + writer.WriteLine(); + writer.Indent(); + } + + private void WriteDescriptor(TextGenerator writer) { + writer.WriteLine("#region Descriptor"); + + writer.WriteLine("public static pbd::FileDescriptor Descriptor {"); + writer.WriteLine(" get { return descriptor; }"); + writer.WriteLine("}"); + writer.WriteLine("private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom("); + writer.WriteLine(" global::System.Convert.FromBase64String("); + writer.Indent(); + writer.Indent(); + + // TODO(jonskeet): Consider a C#-escaping format here instead of just Base64. + byte[] bytes = Descriptor.Proto.ToByteArray(); + string base64 = Convert.ToBase64String(bytes); + + while (base64.Length > 60) { + writer.WriteLine("\"{0}\" + ", base64.Substring(0, 60)); + base64 = base64.Substring(60); + } + writer.WriteLine("\"{0}\"),", base64); + + writer.WriteLine("new pbd::FileDescriptor[] {"); + foreach (FileDescriptor dependency in Descriptor.Dependencies) { + // TODO(jonskeet): The normal code won't work for the bootstrapping descriptor, because we don't get unknown fields :( + if (dependency.Package == "google.protobuf" && dependency.Name.EndsWith("descriptor.proto")) { + writer.WriteLine(" global::" + typeof(DescriptorProtoFile).FullName + ".Descriptor, "); + continue; + } + writer.WriteLine(" {0}.Descriptor, ", DescriptorUtil.GetFullUmbrellaClassName(dependency)); + } + writer.WriteLine("});"); + writer.Outdent(); + writer.Outdent(); + writer.WriteLine("#endregion"); + writer.WriteLine(); + } + } +} diff --git a/src/ProtoGen/app.config b/src/ProtoGen/app.config new file mode 100644 index 00000000..df20690a --- /dev/null +++ b/src/ProtoGen/app.config @@ -0,0 +1,3 @@ +<?xml version="1.0"?> +<configuration> +<startup><supportedRuntime version="v2.0.50727"/></startup></configuration> diff --git a/src/ProtocolBuffers.Test/AbstractMessageTest.cs b/src/ProtocolBuffers.Test/AbstractMessageTest.cs new file mode 100644 index 00000000..38cc8636 --- /dev/null +++ b/src/ProtocolBuffers.Test/AbstractMessageTest.cs @@ -0,0 +1,364 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; +using NUnit.Framework; +using Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class AbstractMessageTest { + + [Test] + public void Clear() { + AbstractMessageWrapper message = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder(TestUtil.GetAllSet())).Clear().Build(); + TestUtil.AssertClear((TestAllTypes) message.WrappedMessage); + } + + [Test] + public void Copy() { + AbstractMessageWrapper message = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder()).MergeFrom(TestUtil.GetAllSet()).Build(); + TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage); + } + + [Test] + public void SerializedSize() { + TestAllTypes message = TestUtil.GetAllSet(); + IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet()); + + Assert.AreEqual(message.SerializedSize, abstractMessage.SerializedSize); + } + + [Test] + public void Serialization() { + IMessage abstractMessage = new AbstractMessageWrapper(TestUtil.GetAllSet()); + TestUtil.AssertAllFieldsSet(TestAllTypes.ParseFrom(abstractMessage.ToByteString())); + Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), abstractMessage.ToByteString()); + } + + [Test] + public void Parsing() { + IBuilder builder = new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder()); + AbstractMessageWrapper message = (AbstractMessageWrapper) builder.WeakMergeFrom(TestUtil.GetAllSet().ToByteString()).WeakBuild(); + TestUtil.AssertAllFieldsSet((TestAllTypes) message.WrappedMessage); + } + + [Test] + public void OptimizedForSize() { + // We're mostly only Checking that this class was compiled successfully. + TestOptimizedForSize message = TestOptimizedForSize.CreateBuilder().SetI(1).Build(); + message = TestOptimizedForSize.ParseFrom(message.ToByteString()); + Assert.AreEqual(2, message.SerializedSize); + } + + // ----------------------------------------------------------------- + // Tests for isInitialized(). + + private static readonly TestRequired TestRequiredUninitialized = TestRequired.DefaultInstance; + private static readonly TestRequired TestRequiredInitialized = TestRequired.CreateBuilder().SetA(1).SetB(2).SetC(3).Build(); + + [Test] + public void IsInitialized() { + TestRequired.Builder builder = TestRequired.CreateBuilder(); + AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder); + + Assert.IsFalse(abstractBuilder.IsInitialized); + builder.A = 1; + Assert.IsFalse(abstractBuilder.IsInitialized); + builder.B = 1; + Assert.IsFalse(abstractBuilder.IsInitialized); + builder.C = 1; + Assert.IsTrue(abstractBuilder.IsInitialized); + } + + [Test] + public void ForeignIsInitialized() { + TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder(); + AbstractMessageWrapper.Builder abstractBuilder = new AbstractMessageWrapper.Builder(builder); + + Assert.IsTrue(abstractBuilder.IsInitialized); + + builder.SetOptionalMessage(TestRequiredUninitialized); + Assert.IsFalse(abstractBuilder.IsInitialized); + + builder.SetOptionalMessage(TestRequiredInitialized); + Assert.IsTrue(abstractBuilder.IsInitialized); + + builder.AddRepeatedMessage(TestRequiredUninitialized); + Assert.IsFalse(abstractBuilder.IsInitialized); + + builder.SetRepeatedMessage(0, TestRequiredInitialized); + Assert.IsTrue(abstractBuilder.IsInitialized); + } + + // ----------------------------------------------------------------- + // Tests for mergeFrom + + static readonly TestAllTypes MergeSource = TestAllTypes.CreateBuilder() + .SetOptionalInt32(1) + .SetOptionalString("foo") + .SetOptionalForeignMessage(ForeignMessage.DefaultInstance) + .AddRepeatedString("bar") + .Build(); + + static readonly TestAllTypes MergeDest = TestAllTypes.CreateBuilder() + .SetOptionalInt64(2) + .SetOptionalString("baz") + .SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(3).Build()) + .AddRepeatedString("qux") + .Build(); + + const string MergeResultText = "optional_int32: 1\n" + + "optional_int64: 2\n" + + "optional_string: \"foo\"\n" + + "optional_foreign_message {\n" + + " c: 3\n" + + "}\n" + + "repeated_string: \"qux\"\n" + + "repeated_string: \"bar\"\n"; + + [Test] + public void MergeFrom() { + AbstractMessageWrapper result = (AbstractMessageWrapper) + new AbstractMessageWrapper.Builder(TestAllTypes.CreateBuilder(MergeDest)) + .MergeFrom(MergeSource) + .Build(); + + Assert.AreEqual(MergeResultText, result.ToString()); + } + + // ----------------------------------------------------------------- + // Tests for equals and hashCode + + [Test] + public void EqualsAndHashCode() { + TestAllTypes a = TestUtil.GetAllSet(); + TestAllTypes b = TestAllTypes.CreateBuilder().Build(); + TestAllTypes c = TestAllTypes.CreateBuilder(b).AddRepeatedString("x").Build(); + TestAllTypes d = TestAllTypes.CreateBuilder(c).AddRepeatedString("y").Build(); + TestAllExtensions e = TestUtil.GetAllExtensionsSet(); + TestAllExtensions f = TestAllExtensions.CreateBuilder(e) + .AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 999).Build(); + + CheckEqualsIsConsistent(a); + CheckEqualsIsConsistent(b); + CheckEqualsIsConsistent(c); + CheckEqualsIsConsistent(d); + CheckEqualsIsConsistent(e); + CheckEqualsIsConsistent(f); + + CheckNotEqual(a, b); + CheckNotEqual(a, c); + CheckNotEqual(a, d); + CheckNotEqual(a, e); + CheckNotEqual(a, f); + + CheckNotEqual(b, c); + CheckNotEqual(b, d); + CheckNotEqual(b, e); + CheckNotEqual(b, f); + + CheckNotEqual(c, d); + CheckNotEqual(c, e); + CheckNotEqual(c, f); + + CheckNotEqual(d, e); + CheckNotEqual(d, f); + + CheckNotEqual(e, f); + } + + /// <summary> + /// Asserts that the given protos are equal and have the same hash code. + /// </summary> + private static void CheckEqualsIsConsistent(IMessage message) { + // Object should be equal to itself. + Assert.AreEqual(message, message); + + // Object should be equal to a dynamic copy of itself. + DynamicMessage dynamic = DynamicMessage.CreateBuilder(message).Build(); + Assert.AreEqual(message, dynamic); + Assert.AreEqual(dynamic, message); + Assert.AreEqual(dynamic.GetHashCode(), message.GetHashCode()); + } + + /// <summary> + /// Asserts that the given protos are not equal and have different hash codes. + /// </summary> + /// <remarks> + /// It's valid for non-equal objects to have the same hash code, so + /// this test is stricter than it needs to be. However, this should happen + /// relatively rarely. (If this test fails, it's probably still due to a bug.) + /// </remarks> + private static void CheckNotEqual(IMessage m1, IMessage m2) { + String equalsError = string.Format("{0} should not be equal to {1}", m1, m2); + Assert.IsFalse(m1.Equals(m2), equalsError); + Assert.IsFalse(m2.Equals(m1), equalsError); + + Assert.IsFalse(m1.GetHashCode() == m2.GetHashCode(), + string.Format("{0} should have a different hash code from {1}", m1, m2)); + } + + /// <summary> + /// Extends AbstractMessage and wraps some other message object. The methods + /// of the Message interface which aren't explicitly implemented by + /// AbstractMessage are forwarded to the wrapped object. This allows us to + /// test that AbstractMessage's implementations work even if the wrapped + /// object does not use them. + /// </summary> + private class AbstractMessageWrapper : AbstractMessage<AbstractMessageWrapper, AbstractMessageWrapper.Builder> { + private readonly IMessage wrappedMessage; + + public IMessage WrappedMessage { + get { return wrappedMessage; } + } + + public AbstractMessageWrapper(IMessage wrappedMessage) { + this.wrappedMessage = wrappedMessage; + } + + public override MessageDescriptor DescriptorForType { + get { return wrappedMessage.DescriptorForType; } + } + + public override AbstractMessageWrapper DefaultInstanceForType { + get { return new AbstractMessageWrapper(wrappedMessage.WeakDefaultInstanceForType); } + } + + public override IDictionary<FieldDescriptor, object> AllFields { + get { return wrappedMessage.AllFields; } + } + + public override bool HasField(FieldDescriptor field) { + return wrappedMessage.HasField(field); + } + + public override object this[FieldDescriptor field] { + get { return wrappedMessage[field]; } + } + + public override object this[FieldDescriptor field, int index] { + get { return wrappedMessage[field, index]; } + } + + public override int GetRepeatedFieldCount(FieldDescriptor field) { + return wrappedMessage.GetRepeatedFieldCount(field); + } + + public override UnknownFieldSet UnknownFields { + get { return wrappedMessage.UnknownFields; } + } + + public override Builder CreateBuilderForType() { + return new Builder(wrappedMessage.WeakCreateBuilderForType()); + } + + internal class Builder : AbstractBuilder<AbstractMessageWrapper, Builder> { + private readonly IBuilder wrappedBuilder; + + protected override Builder ThisBuilder { + get { return this; } + } + + internal Builder(IBuilder wrappedBuilder) { + this.wrappedBuilder = wrappedBuilder; + } + + public override Builder MergeFrom(AbstractMessageWrapper other) { + wrappedBuilder.WeakMergeFrom(other.wrappedMessage); + return this; + } + + public override bool IsInitialized { + get { return wrappedBuilder.IsInitialized; } + } + + public override IDictionary<FieldDescriptor, object> AllFields { + get { return wrappedBuilder.AllFields; } + } + + public override object this[FieldDescriptor field] { + get { return wrappedBuilder[field]; } + set { wrappedBuilder[field] = value; } + } + + public override MessageDescriptor DescriptorForType { + get { return wrappedBuilder.DescriptorForType; } + } + + public override int GetRepeatedFieldCount(FieldDescriptor field) { + return wrappedBuilder.GetRepeatedFieldCount(field); + } + + public override object this[FieldDescriptor field, int index] { + get { return wrappedBuilder[field, index]; } + set { wrappedBuilder[field, index] = value; } + } + + public override bool HasField(FieldDescriptor field) { + return wrappedBuilder.HasField(field); + } + + public override UnknownFieldSet UnknownFields { + get { return wrappedBuilder.UnknownFields; } + set { wrappedBuilder.UnknownFields = value; } + } + + public override AbstractMessageWrapper Build() { + return new AbstractMessageWrapper(wrappedBuilder.WeakBuild()); + } + + public override AbstractMessageWrapper BuildPartial() { + return new AbstractMessageWrapper(wrappedBuilder.WeakBuildPartial()); + } + + public override Builder Clone() { + return new Builder(wrappedBuilder.WeakClone()); + } + + public override AbstractMessageWrapper DefaultInstanceForType { + get { return new AbstractMessageWrapper(wrappedBuilder.WeakDefaultInstanceForType); } + } + + public override Builder ClearField(FieldDescriptor field) { + wrappedBuilder.WeakClearField(field); + return this; + } + + public override Builder AddRepeatedField(FieldDescriptor field, object value) { + wrappedBuilder.WeakAddRepeatedField(field, value); + return this; + } + + public override IBuilder CreateBuilderForField(FieldDescriptor field) { + wrappedBuilder.CreateBuilderForField(field); + return this; + } + + public override Builder MergeFrom(IMessage other) { + wrappedBuilder.WeakMergeFrom(other); + return this; + } + + public override Builder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry) { + wrappedBuilder.WeakMergeFrom(input, extensionRegistry); + return this; + } + } + } + } +} diff --git a/src/ProtocolBuffers.Test/ByteStringTest.cs b/src/ProtocolBuffers.Test/ByteStringTest.cs new file mode 100644 index 00000000..768d74fe --- /dev/null +++ b/src/ProtocolBuffers.Test/ByteStringTest.cs @@ -0,0 +1,98 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Text; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class ByteStringTest { + [Test] + public void EmptyByteStringHasZeroSize() { + Assert.AreEqual(0, ByteString.Empty.Length); + } + + [Test] + public void CopyFromStringWithExplicitEncoding() { + ByteString bs = ByteString.CopyFrom("AB", Encoding.Unicode); + Assert.AreEqual(4, bs.Length); + Assert.AreEqual(65, bs[0]); + Assert.AreEqual(0, bs[1]); + Assert.AreEqual(66, bs[2]); + Assert.AreEqual(0, bs[3]); + } + + [Test] + public void IsEmptyWhenEmpty() { + Assert.IsTrue(ByteString.CopyFromUtf8("").IsEmpty); + } + + [Test] + public void IsEmptyWhenNotEmpty() { + Assert.IsFalse(ByteString.CopyFromUtf8("X").IsEmpty); + } + + [Test] + public void CopyFromByteArrayCopiesContents() { + byte[] data = new byte[1]; + data[0] = 10; + ByteString bs = ByteString.CopyFrom(data); + Assert.AreEqual(10, bs[0]); + data[0] = 5; + Assert.AreEqual(10, bs[0]); + } + + [Test] + public void ToByteArrayCopiesContents() { + ByteString bs = ByteString.CopyFromUtf8("Hello"); + byte[] data = bs.ToByteArray(); + Assert.AreEqual('H', data[0]); + Assert.AreEqual('H', bs[0]); + data[0] = 0; + Assert.AreEqual(0, data[0]); + Assert.AreEqual('H', bs[0]); + } + + [Test] + public void CopyFromUtf8UsesUtf8() { + ByteString bs = ByteString.CopyFromUtf8("\u20ac"); + Assert.AreEqual(3, bs.Length); + Assert.AreEqual(0xe2, bs[0]); + Assert.AreEqual(0x82, bs[1]); + Assert.AreEqual(0xac, bs[2]); + } + + [Test] + public void CopyFromPortion() { + byte[] data = new byte[]{0, 1, 2, 3, 4, 5, 6}; + ByteString bs = ByteString.CopyFrom(data, 2, 3); + Assert.AreEqual(3, bs.Length); + Assert.AreEqual(2, bs[0]); + Assert.AreEqual(3, bs[1]); + } + + [Test] + public void ToStringUtf8() { + ByteString bs = ByteString.CopyFromUtf8("\u20ac"); + Assert.AreEqual("\u20ac", bs.ToStringUtf8()); + } + + [Test] + public void ToStringWithExplicitEncoding() { + ByteString bs = ByteString.CopyFrom("\u20ac", Encoding.Unicode); + Assert.AreEqual("\u20ac", bs.ToString(Encoding.Unicode)); + } + } +} diff --git a/src/ProtocolBuffers.Test/CodedInputStreamTest.cs b/src/ProtocolBuffers.Test/CodedInputStreamTest.cs new file mode 100644 index 00000000..24b3a732 --- /dev/null +++ b/src/ProtocolBuffers.Test/CodedInputStreamTest.cs @@ -0,0 +1,376 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.IO; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; +using System.Diagnostics; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class CodedInputStreamTest { + + /// <summary> + /// Helper to construct a byte array from a bunch of bytes. The inputs are + /// actually ints so that I can use hex notation and not get stupid errors + /// about precision. + /// </summary> + private static byte[] Bytes(params int[] bytesAsInts) { + byte[] bytes = new byte[bytesAsInts.Length]; + for (int i = 0; i < bytesAsInts.Length; i++) { + bytes[i] = (byte)bytesAsInts[i]; + } + return bytes; + } + + /// <summary> + /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and + /// </summary> + private static void AssertReadVarint(byte[] data, ulong value) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + Assert.AreEqual((uint)value, input.ReadRawVarint32()); + + input = CodedInputStream.CreateInstance(data); + Assert.AreEqual(value, input.ReadRawVarint64()); + + // Try different block sizes. + for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { + input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize)); + Assert.AreEqual((uint)value, input.ReadRawVarint32()); + + input = CodedInputStream.CreateInstance(new SmallBlockInputStream(data, bufferSize)); + Assert.AreEqual(value, input.ReadRawVarint64()); + } + } + + /// <summary> + /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and + /// expects them to fail with an InvalidProtocolBufferException whose + /// description matches the given one. + /// </summary> + private void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + try { + input.ReadRawVarint32(); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual(expected.Message, e.Message); + } + + input = CodedInputStream.CreateInstance(data); + try { + input.ReadRawVarint64(); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual(expected.Message, e.Message); + } + } + + [Test] + public void ReadVarint() { + AssertReadVarint(Bytes(0x00), 0); + AssertReadVarint(Bytes(0x01), 1); + AssertReadVarint(Bytes(0x7f), 127); + // 14882 + AssertReadVarint(Bytes(0xa2, 0x74), (0x22 << 0) | (0x74 << 7)); + // 2961488830 + AssertReadVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b), + (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | + (0x0bL << 28)); + + // 64-bit + // 7256456126 + AssertReadVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b), + (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | + (0x1bL << 28)); + // 41256202580718336 + AssertReadVarint(Bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49), + (0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) | + (0x43L << 28) | (0x49L << 35) | (0x24L << 42) | (0x49L << 49)); + // 11964378330978735131 + AssertReadVarint(Bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01), + (0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) | + (0x3bUL << 28) | (0x56UL << 35) | (0x00UL << 42) | + (0x05UL << 49) | (0x26UL << 56) | (0x01UL << 63)); + + // Failures + AssertReadVarintFailure( + InvalidProtocolBufferException.MalformedVarint(), + Bytes(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x00)); + AssertReadVarintFailure( + InvalidProtocolBufferException.TruncatedMessage(), + Bytes(0x80)); + } + + /// <summary> + /// Parses the given bytes using ReadRawLittleEndian32() and checks + /// that the result matches the given value. + /// </summary> + private static void AssertReadLittleEndian32(byte[] data, uint value) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + Assert.AreEqual(value, input.ReadRawLittleEndian32()); + + // Try different block sizes. + for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { + input = CodedInputStream.CreateInstance( + new SmallBlockInputStream(data, blockSize)); + Assert.AreEqual(value, input.ReadRawLittleEndian32()); + } + } + + /// <summary> + /// Parses the given bytes using ReadRawLittleEndian64() and checks + /// that the result matches the given value. + /// </summary> + private static void AssertReadLittleEndian64(byte[] data, ulong value) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + Assert.AreEqual(value, input.ReadRawLittleEndian64()); + + // Try different block sizes. + for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { + input = CodedInputStream.CreateInstance( + new SmallBlockInputStream(data, blockSize)); + Assert.AreEqual(value, input.ReadRawLittleEndian64()); + } + } + + [Test] + public void ReadLittleEndian() { + AssertReadLittleEndian32(Bytes(0x78, 0x56, 0x34, 0x12), 0x12345678); + AssertReadLittleEndian32(Bytes(0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef0); + + AssertReadLittleEndian64(Bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12), + 0x123456789abcdef0L); + AssertReadLittleEndian64( + Bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef012345678UL); + } + + [Test] + public void DecodeZigZag32() { + Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(0)); + Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(1)); + Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(2)); + Assert.AreEqual(-2, CodedInputStream.DecodeZigZag32(3)); + Assert.AreEqual(0x3FFFFFFF, CodedInputStream.DecodeZigZag32(0x7FFFFFFE)); + Assert.AreEqual(unchecked((int)0xC0000000), CodedInputStream.DecodeZigZag32(0x7FFFFFFF)); + Assert.AreEqual(0x7FFFFFFF, CodedInputStream.DecodeZigZag32(0xFFFFFFFE)); + Assert.AreEqual(unchecked((int)0x80000000), CodedInputStream.DecodeZigZag32(0xFFFFFFFF)); + } + + [Test] + public void DecodeZigZag64() { + Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(0)); + Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(1)); + Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(2)); + Assert.AreEqual(-2, CodedInputStream.DecodeZigZag64(3)); + Assert.AreEqual(0x000000003FFFFFFFL, CodedInputStream.DecodeZigZag64(0x000000007FFFFFFEL)); + Assert.AreEqual(unchecked((long)0xFFFFFFFFC0000000L), CodedInputStream.DecodeZigZag64(0x000000007FFFFFFFL)); + Assert.AreEqual(0x000000007FFFFFFFL, CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFEL)); + Assert.AreEqual(unchecked((long)0xFFFFFFFF80000000L), CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFFL)); + Assert.AreEqual(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL)); + Assert.AreEqual(unchecked((long)0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL)); + } + + [Test] + public void ReadWholeMessage() { + TestAllTypes message = TestUtil.GetAllSet(); + + byte[] rawBytes = message.ToByteArray(); + Assert.AreEqual(rawBytes.Length, message.SerializedSize); + TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); + TestUtil.AssertAllFieldsSet(message2); + + // Try different block sizes. + for (int blockSize = 1; blockSize < 256; blockSize *= 2) { + message2 = TestAllTypes.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize)); + TestUtil.AssertAllFieldsSet(message2); + } + } + + [Test] + public void SkipWholeMessage() { + TestAllTypes message = TestUtil.GetAllSet(); + byte[] rawBytes = message.ToByteArray(); + + // Create two parallel inputs. Parse one as unknown fields while using + // skipField() to skip each field on the other. Expect the same tags. + CodedInputStream input1 = CodedInputStream.CreateInstance(rawBytes); + CodedInputStream input2 = CodedInputStream.CreateInstance(rawBytes); + UnknownFieldSet.Builder unknownFields = UnknownFieldSet.CreateBuilder(); + + while (true) { + uint tag = input1.ReadTag(); + Assert.AreEqual(tag, input2.ReadTag()); + if (tag == 0) { + break; + } + unknownFields.MergeFieldFrom(tag, input1); + input2.SkipField(tag); + } + } + + public void ReadHugeBlob() { + // Allocate and initialize a 1MB blob. + byte[] blob = new byte[1 << 20]; + for (int i = 0; i < blob.Length; i++) { + blob[i] = (byte)i; + } + + // Make a message containing it. + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + builder.SetOptionalBytes(ByteString.CopyFrom(blob)); + TestAllTypes message = builder.Build(); + + // Serialize and parse it. Make sure to parse from an InputStream, not + // directly from a ByteString, so that CodedInputStream uses buffered + // reading. + TestAllTypes message2 = TestAllTypes.ParseFrom(message.ToByteString().CreateCodedInput()); + + Assert.AreEqual(message.OptionalBytes, message2.OptionalBytes); + + // Make sure all the other fields were parsed correctly. + TestAllTypes message3 = TestAllTypes.CreateBuilder(message2) + .SetOptionalBytes(TestUtil.GetAllSet().OptionalBytes) + .Build(); + TestUtil.AssertAllFieldsSet(message3); + } + + [Test] + public void ReadMaliciouslyLargeBlob() { + MemoryStream ms = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(ms); + + uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); + output.WriteRawVarint32(tag); + output.WriteRawVarint32(0x7FFFFFFF); + output.WriteRawBytes(new byte[32]); // Pad with a few random bytes. + output.Flush(); + ms.Position = 0; + + CodedInputStream input = CodedInputStream.CreateInstance(ms); + Assert.AreEqual(tag, input.ReadTag()); + + try { + input.ReadBytes(); + Assert.Fail("Should have thrown an exception!"); + } catch (InvalidProtocolBufferException) { + // success. + } + } + + private static TestRecursiveMessage MakeRecursiveMessage(int depth) { + if (depth == 0) { + return TestRecursiveMessage.CreateBuilder().SetI(5).Build(); + } else { + return TestRecursiveMessage.CreateBuilder() + .SetA(MakeRecursiveMessage(depth - 1)).Build(); + } + } + + private static void AssertMessageDepth(TestRecursiveMessage message, int depth) { + if (depth == 0) { + Assert.IsFalse(message.HasA); + Assert.AreEqual(5, message.I); + } else { + Assert.IsTrue(message.HasA); + AssertMessageDepth(message.A, depth - 1); + } + } + + [Test] + public void MaliciousRecursion() { + ByteString data64 = MakeRecursiveMessage(64).ToByteString(); + ByteString data65 = MakeRecursiveMessage(65).ToByteString(); + + AssertMessageDepth(TestRecursiveMessage.ParseFrom(data64), 64); + + try { + TestRecursiveMessage.ParseFrom(data65); + Assert.Fail("Should have thrown an exception!"); + } catch (InvalidProtocolBufferException) { + // success. + } + + CodedInputStream input = data64.CreateCodedInput(); + input.SetRecursionLimit(8); + try { + TestRecursiveMessage.ParseFrom(input); + Assert.Fail("Should have thrown an exception!"); + } catch (InvalidProtocolBufferException) { + // success. + } + } + + [Test] + public void SizeLimit() { + // Have to use a Stream rather than ByteString.CreateCodedInput as SizeLimit doesn't + // apply to the latter case. + MemoryStream ms = new MemoryStream(TestUtil.GetAllSet().ToByteString().ToByteArray()); + CodedInputStream input = CodedInputStream.CreateInstance(ms); + input.SetSizeLimit(16); + + try { + TestAllTypes.ParseFrom(input); + Assert.Fail("Should have thrown an exception!"); + } catch (InvalidProtocolBufferException) { + // success. + } + } + + /// <summary> + /// Tests that if we read an string that contains invalid UTF-8, no exception + /// is thrown. Instead, the invalid bytes are replaced with the Unicode + /// "replacement character" U+FFFD. + /// </summary> + [Test] + public void ReadInvalidUtf8() { + MemoryStream ms = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(ms); + + uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); + output.WriteRawVarint32(tag); + output.WriteRawVarint32(1); + output.WriteRawBytes(new byte[] { 0x80 }); + output.Flush(); + ms.Position = 0; + + CodedInputStream input = CodedInputStream.CreateInstance(ms); + Assert.AreEqual(tag, input.ReadTag()); + string text = input.ReadString(); + Assert.AreEqual('\ufffd', text[0]); + } + + /// <summary> + /// A stream which limits the number of bytes it reads at a time. + /// We use this to make sure that CodedInputStream doesn't screw up when + /// reading in small blocks. + /// </summary> + private sealed class SmallBlockInputStream : MemoryStream { + private readonly int blockSize; + + public SmallBlockInputStream(byte[] data, int blockSize) + : base(data) { + this.blockSize = blockSize; + } + + public override int Read(byte[] buffer, int offset, int count) { + return base.Read(buffer, offset, Math.Min(count, blockSize)); + } + } + } +} diff --git a/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs new file mode 100644 index 00000000..d6a4e672 --- /dev/null +++ b/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs @@ -0,0 +1,239 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.IO; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class CodedOutputStreamTest { + + /// <summary> + /// Writes the given value using WriteRawVarint32() and WriteRawVarint64() and + /// checks that the result matches the given bytes + /// </summary> + private static void AssertWriteVarint(byte[] data, ulong value) { + // Only do 32-bit write if the value fits in 32 bits. + if ((value >> 32) == 0) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); + output.WriteRawVarint32((uint) value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + // Also try computing size. + Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value)); + } + + { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); + output.WriteRawVarint64(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + + // Also try computing size. + Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value)); + } + + // Try different buffer sizes. + for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { + // Only do 32-bit write if the value fits in 32 bits. + if ((value >> 32) == 0) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = + CodedOutputStream.CreateInstance(rawOutput, bufferSize); + output.WriteRawVarint32((uint) value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + } + + { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput, bufferSize); + output.WriteRawVarint64(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + } + } + } + + /// <summary> + /// Tests WriteRawVarint32() and WriteRawVarint64() + /// </summary> + [Test] + public void WriteVarint() { + AssertWriteVarint(new byte[] {0x00}, 0); + AssertWriteVarint(new byte[] {0x01}, 1); + AssertWriteVarint(new byte[] {0x7f}, 127); + // 14882 + AssertWriteVarint(new byte[] {0xa2, 0x74}, (0x22 << 0) | (0x74 << 7)); + // 2961488830 + AssertWriteVarint(new byte[] {0xbe, 0xf7, 0x92, 0x84, 0x0b}, + (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | + (0x0bL << 28)); + + // 64-bit + // 7256456126 + AssertWriteVarint(new byte[] {0xbe, 0xf7, 0x92, 0x84, 0x1b}, + (0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | + (0x1bL << 28)); + // 41256202580718336 + AssertWriteVarint( + new byte[] {0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49}, + (0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) | + (0x43UL << 28) | (0x49L << 35) | (0x24UL << 42) | (0x49UL << 49)); + // 11964378330978735131 + AssertWriteVarint( + new byte[] {0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01}, + unchecked((ulong) + ((0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) | + (0x3bL << 28) | (0x56L << 35) | (0x00L << 42) | + (0x05L << 49) | (0x26L << 56) | (0x01L << 63)))); + } + + /// <summary> + /// Parses the given bytes using WriteRawLittleEndian32() and checks + /// that the result matches the given value. + /// </summary> + private static void AssertWriteLittleEndian32(byte[] data, uint value) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); + output.WriteRawLittleEndian32(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + + // Try different buffer sizes. + for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) { + rawOutput = new MemoryStream(); + output = CodedOutputStream.CreateInstance(rawOutput, bufferSize); + output.WriteRawLittleEndian32(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + } + } + + /// <summary> + /// Parses the given bytes using WriteRawLittleEndian64() and checks + /// that the result matches the given value. + /// </summary> + private static void AssertWriteLittleEndian64(byte[] data, ulong value) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput); + output.WriteRawLittleEndian64(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + + // Try different block sizes. + for (int blockSize = 1; blockSize <= 16; blockSize *= 2) { + rawOutput = new MemoryStream(); + output = CodedOutputStream.CreateInstance(rawOutput, blockSize); + output.WriteRawLittleEndian64(value); + output.Flush(); + Assert.AreEqual(data, rawOutput.ToArray()); + } + } + + /// <summary> + /// Tests writeRawLittleEndian32() and writeRawLittleEndian64(). + /// </summary> + [Test] + public void WriteLittleEndian() { + AssertWriteLittleEndian32(new byte[] {0x78, 0x56, 0x34, 0x12}, 0x12345678); + AssertWriteLittleEndian32(new byte[] {0xf0, 0xde, 0xbc, 0x9a}, 0x9abcdef0); + + AssertWriteLittleEndian64( + new byte[]{0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12}, + 0x123456789abcdef0L); + AssertWriteLittleEndian64( + new byte[]{0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a}, + 0x9abcdef012345678UL); + } + + [Test] + public void WriteWholeMessage() { + TestAllTypes message = TestUtil.GetAllSet(); + + byte[] rawBytes = message.ToByteArray(); + TestUtil.AssertEqualBytes(TestUtil.GoldenMessage.ToByteArray(), rawBytes); + + // Try different block sizes. + for (int blockSize = 1; blockSize < 256; blockSize *= 2) { + MemoryStream rawOutput = new MemoryStream(); + CodedOutputStream output = + CodedOutputStream.CreateInstance(rawOutput, blockSize); + message.WriteTo(output); + output.Flush(); + TestUtil.AssertEqualBytes(rawBytes, rawOutput.ToArray()); + } + } + + + [Test] + public void EncodeZigZag32() { + Assert.AreEqual(0, CodedOutputStream.EncodeZigZag32( 0)); + Assert.AreEqual(1, CodedOutputStream.EncodeZigZag32(-1)); + Assert.AreEqual(2, CodedOutputStream.EncodeZigZag32( 1)); + Assert.AreEqual(3, CodedOutputStream.EncodeZigZag32(-2)); + Assert.AreEqual(0x7FFFFFFE, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF)); + Assert.AreEqual(0x7FFFFFFF, CodedOutputStream.EncodeZigZag32(unchecked((int)0xC0000000))); + Assert.AreEqual(0xFFFFFFFE, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF)); + Assert.AreEqual(0xFFFFFFFF, CodedOutputStream.EncodeZigZag32(unchecked((int)0x80000000))); + } + + [Test] + public void EncodeZigZag64() { + Assert.AreEqual(0, CodedOutputStream.EncodeZigZag64( 0)); + Assert.AreEqual(1, CodedOutputStream.EncodeZigZag64(-1)); + Assert.AreEqual(2, CodedOutputStream.EncodeZigZag64( 1)); + Assert.AreEqual(3, CodedOutputStream.EncodeZigZag64(-2)); + Assert.AreEqual(0x000000007FFFFFFEL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0x000000003FFFFFFFUL))); + Assert.AreEqual(0x000000007FFFFFFFL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0xFFFFFFFFC0000000UL))); + Assert.AreEqual(0x00000000FFFFFFFEL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0x000000007FFFFFFFUL))); + Assert.AreEqual(0x00000000FFFFFFFFL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0xFFFFFFFF80000000UL))); + Assert.AreEqual(0xFFFFFFFFFFFFFFFEL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0x7FFFFFFFFFFFFFFFUL))); + Assert.AreEqual(0xFFFFFFFFFFFFFFFFL, + CodedOutputStream.EncodeZigZag64(unchecked((long)0x8000000000000000UL))); + } + + [Test] + public void RoundTripZigZag32() { + // Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1) + // were chosen semi-randomly via keyboard bashing. + Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0))); + Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1))); + Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1))); + Assert.AreEqual(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927))); + Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612))); + } + + [Test] + public void RoundTripZigZag64() { + Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0))); + Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1))); + Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1))); + Assert.AreEqual(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927))); + Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612))); + + Assert.AreEqual(856912304801416L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L))); + Assert.AreEqual(-75123905439571256L, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L))); + } + } +} diff --git a/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs b/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs new file mode 100644 index 00000000..6943672d --- /dev/null +++ b/src/ProtocolBuffers.Test/Collections/PopsicleListTest.cs @@ -0,0 +1,64 @@ +using System; +using System.Collections.Generic; +using System.Text; +using NUnit.Framework; + +namespace Google.ProtocolBuffers.Collections { + [TestFixture] + public class PopsicleListTest { + + [Test] + public void MutatingOperationsOnFrozenList() { + PopsicleList<string> list = new PopsicleList<string>(); + list.MakeReadOnly(); + AssertNotSupported(() => list.Add("")); + AssertNotSupported(() => list.Clear()); + AssertNotSupported(() => list.Insert(0, "")); + AssertNotSupported(() => list.Remove("")); + AssertNotSupported(() => list.RemoveAt(0)); + } + + [Test] + public void NonMutatingOperationsOnFrozenList() { + PopsicleList<string> list = new PopsicleList<string>(); + list.MakeReadOnly(); + Assert.IsFalse(list.Contains("")); + Assert.AreEqual(0, list.Count); + list.CopyTo(new string[5], 0); + list.GetEnumerator(); + Assert.AreEqual(-1, list.IndexOf("")); + Assert.IsTrue(list.IsReadOnly); + } + + [Test] + public void MutatingOperationsOnFluidList() { + PopsicleList<string> list = new PopsicleList<string>(); + list.Add(""); + list.Clear(); + list.Insert(0, ""); + list.Remove(""); + list.Add("x"); // Just to make the next call valid + list.RemoveAt(0); + } + + [Test] + public void NonMutatingOperationsOnFluidList() { + PopsicleList<string> list = new PopsicleList<string>(); + Assert.IsFalse(list.Contains("")); + Assert.AreEqual(0, list.Count); + list.CopyTo(new string[5], 0); + list.GetEnumerator(); + Assert.AreEqual(-1, list.IndexOf("")); + Assert.IsFalse(list.IsReadOnly); + } + + private static void AssertNotSupported(Action action) { + try { + action(); + Assert.Fail("Expected NotSupportedException"); + } catch (NotSupportedException) { + // Expected + } + } + } +} diff --git a/src/ProtocolBuffers.Test/DescriptorsTest.cs b/src/ProtocolBuffers.Test/DescriptorsTest.cs new file mode 100644 index 00000000..c997e75a --- /dev/null +++ b/src/ProtocolBuffers.Test/DescriptorsTest.cs @@ -0,0 +1,274 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.Text; +using NUnit.Framework; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Tests for descriptors. (Not in its own namespace or broken up into individual classes as the + /// size doesn't warrant it. On the other hand, this makes me feel a bit dirty...) + /// </summary> + [TestFixture] + public class DescriptorsTest { + + [Test] + public void FileDescriptor() { + FileDescriptor file = UnitTestProtoFile.Descriptor; + + Assert.AreEqual("google/protobuf/unittest.proto", file.Name); + Assert.AreEqual("protobuf_unittest", file.Package); + + Assert.AreEqual("UnittestProto", file.Options.JavaOuterClassname); + Assert.AreEqual("google/protobuf/unittest.proto", file.Proto.Name); + +// TODO(jonskeet): Either change to expect 3 dependencies, or don't emit them. +// Assert.AreEqual(1, file.Dependencies.Count); + Assert.AreEqual(UnitTestImportProtoFile.Descriptor, file.Dependencies[2]); + + MessageDescriptor messageType = TestAllTypes.Descriptor; + Assert.AreEqual(messageType, file.MessageTypes[0]); + Assert.AreEqual(messageType, file.FindTypeByName<MessageDescriptor>("TestAllTypes")); + Assert.IsNull(file.FindTypeByName<MessageDescriptor>("NoSuchType")); + Assert.IsNull(file.FindTypeByName<MessageDescriptor>("protobuf_unittest.TestAllTypes")); + for (int i = 0; i < file.MessageTypes.Count; i++) { + Assert.AreEqual(i, file.MessageTypes[i].Index); + } + + Assert.AreEqual(file.EnumTypes[0], file.FindTypeByName<EnumDescriptor>("ForeignEnum")); + Assert.IsNull(file.FindTypeByName<EnumDescriptor>("NoSuchType")); + Assert.IsNull(file.FindTypeByName<EnumDescriptor>("protobuf_unittest.ForeignEnum")); + Assert.AreEqual(1, UnitTestImportProtoFile.Descriptor.EnumTypes.Count); + Assert.AreEqual("ImportEnum", UnitTestImportProtoFile.Descriptor.EnumTypes[0].Name); + for (int i = 0; i < file.EnumTypes.Count; i++) { + Assert.AreEqual(i, file.EnumTypes[i].Index); + } + + ServiceDescriptor service = TestService.Descriptor; + Assert.AreEqual(service, file.Services[0]); + Assert.AreEqual(service, file.FindTypeByName<ServiceDescriptor>("TestService")); + Assert.IsNull(file.FindTypeByName<ServiceDescriptor>("NoSuchType")); + Assert.IsNull(file.FindTypeByName<ServiceDescriptor>("protobuf_unittest.TestService")); + Assert.AreEqual(0, UnitTestImportProtoFile.Descriptor.Services.Count); + for (int i = 0; i < file.Services.Count; i++) { + Assert.AreEqual(i, file.Services[i].Index); + } + + FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor; + Assert.AreEqual(extension, file.Extensions[0]); + Assert.AreEqual(extension, file.FindTypeByName<FieldDescriptor>("optional_int32_extension")); + Assert.IsNull(file.FindTypeByName<FieldDescriptor>("no_such_ext")); + Assert.IsNull(file.FindTypeByName<FieldDescriptor>("protobuf_unittest.optional_int32_extension")); + Assert.AreEqual(0, UnitTestImportProtoFile.Descriptor.Extensions.Count); + for (int i = 0; i < file.Extensions.Count; i++) { + Assert.AreEqual(i, file.Extensions[i].Index); + } + } + + [Test] + public void MessageDescriptor() { + MessageDescriptor messageType = TestAllTypes.Descriptor; + MessageDescriptor nestedType = TestAllTypes.Types.NestedMessage.Descriptor; + + Assert.AreEqual("TestAllTypes", messageType.Name); + Assert.AreEqual("protobuf_unittest.TestAllTypes", messageType.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, messageType.File); + Assert.IsNull(messageType.ContainingType); + Assert.AreEqual(DescriptorProtos.MessageOptions.DefaultInstance, messageType.Options); + Assert.AreEqual("TestAllTypes", messageType.Proto.Name); + + Assert.AreEqual("NestedMessage", nestedType.Name); + Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedMessage", nestedType.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, nestedType.File); + Assert.AreEqual(messageType, nestedType.ContainingType); + + FieldDescriptor field = messageType.Fields[0]; + Assert.AreEqual("optional_int32", field.Name); + Assert.AreEqual(field, messageType.FindDescriptor<FieldDescriptor>("optional_int32")); + Assert.IsNull(messageType.FindDescriptor<FieldDescriptor>("no_such_field")); + Assert.AreEqual(field, messageType.FindFieldByNumber(1)); + Assert.IsNull(messageType.FindFieldByNumber(571283)); + for (int i = 0; i < messageType.Fields.Count; i++) { + Assert.AreEqual(i, messageType.Fields[i].Index); + } + + Assert.AreEqual(nestedType, messageType.NestedTypes[0]); + Assert.AreEqual(nestedType, messageType.FindDescriptor<MessageDescriptor>("NestedMessage")); + Assert.IsNull(messageType.FindDescriptor<MessageDescriptor>("NoSuchType")); + for (int i = 0; i < messageType.NestedTypes.Count; i++) { + Assert.AreEqual(i, messageType.NestedTypes[i].Index); + } + + Assert.AreEqual(messageType.EnumTypes[0], messageType.FindDescriptor<EnumDescriptor>("NestedEnum")); + Assert.IsNull(messageType.FindDescriptor<EnumDescriptor>("NoSuchType")); + for (int i = 0; i < messageType.EnumTypes.Count; i++) { + Assert.AreEqual(i, messageType.EnumTypes[i].Index); + } + } + + [Test] + public void FieldDescriptor() { + MessageDescriptor messageType = TestAllTypes.Descriptor; + FieldDescriptor primitiveField = messageType.FindDescriptor<FieldDescriptor>("optional_int32"); + FieldDescriptor enumField = messageType.FindDescriptor<FieldDescriptor>("optional_nested_enum"); + FieldDescriptor messageField = messageType.FindDescriptor<FieldDescriptor>("optional_foreign_message"); + FieldDescriptor cordField = messageType.FindDescriptor<FieldDescriptor>("optional_cord"); + FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor; + FieldDescriptor nestedExtension = TestRequired.Single.Descriptor; + + Assert.AreEqual("optional_int32", primitiveField.Name); + Assert.AreEqual("protobuf_unittest.TestAllTypes.optional_int32", + primitiveField.FullName); + Assert.AreEqual(1, primitiveField.FieldNumber); + Assert.AreEqual(messageType, primitiveField.ContainingType); + Assert.AreEqual(UnitTestProtoFile.Descriptor, primitiveField.File); + Assert.AreEqual(FieldType.Int32, primitiveField.FieldType); + Assert.AreEqual(MappedType.Int32, primitiveField.MappedType); + Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance, primitiveField.Options); + Assert.IsFalse(primitiveField.IsExtension); + Assert.AreEqual("optional_int32", primitiveField.Proto.Name); + + Assert.AreEqual("optional_nested_enum", enumField.Name); + Assert.AreEqual(FieldType.Enum, enumField.FieldType); + Assert.AreEqual(MappedType.Enum, enumField.MappedType); + // Assert.AreEqual(TestAllTypes.Types.NestedEnum.Descriptor, enumField.EnumType); + + Assert.AreEqual("optional_foreign_message", messageField.Name); + Assert.AreEqual(FieldType.Message, messageField.FieldType); + Assert.AreEqual(MappedType.Message, messageField.MappedType); + Assert.AreEqual(ForeignMessage.Descriptor, messageField.MessageType); + + Assert.AreEqual("optional_cord", cordField.Name); + Assert.AreEqual(FieldType.String, cordField.FieldType); + Assert.AreEqual(MappedType.String, cordField.MappedType); + Assert.AreEqual(DescriptorProtos.FieldOptions.Types.CType.CORD, cordField.Options.Ctype); + + Assert.AreEqual("optional_int32_extension", extension.Name); + Assert.AreEqual("protobuf_unittest.optional_int32_extension", extension.FullName); + Assert.AreEqual(1, extension.FieldNumber); + Assert.AreEqual(TestAllExtensions.Descriptor, extension.ContainingType); + Assert.AreEqual(UnitTestProtoFile.Descriptor, extension.File); + Assert.AreEqual(FieldType.Int32, extension.FieldType); + Assert.AreEqual(MappedType.Int32, extension.MappedType); + Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance, + extension.Options); + Assert.IsTrue(extension.IsExtension); + Assert.AreEqual(null, extension.ExtensionScope); + Assert.AreEqual("optional_int32_extension", extension.Proto.Name); + + Assert.AreEqual("single", nestedExtension.Name); + Assert.AreEqual("protobuf_unittest.TestRequired.single", + nestedExtension.FullName); + Assert.AreEqual(TestRequired.Descriptor, + nestedExtension.ExtensionScope); + } + + [Test] + public void FieldDescriptorLabel() { + FieldDescriptor requiredField = + TestRequired.Descriptor.FindDescriptor<FieldDescriptor>("a"); + FieldDescriptor optionalField = + TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("optional_int32"); + FieldDescriptor repeatedField = + TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("repeated_int32"); + + Assert.IsTrue(requiredField.IsRequired); + Assert.IsFalse(requiredField.IsRepeated); + Assert.IsFalse(optionalField.IsRequired); + Assert.IsFalse(optionalField.IsRepeated); + Assert.IsFalse(repeatedField.IsRequired); + Assert.IsTrue(repeatedField.IsRepeated); + } + + [Test] + public void FieldDescriptorDefault() { + MessageDescriptor d = TestAllTypes.Descriptor; + Assert.IsFalse(d.FindDescriptor<FieldDescriptor>("optional_int32").HasDefaultValue); + Assert.AreEqual(0, d.FindDescriptor<FieldDescriptor>("optional_int32").DefaultValue); + Assert.IsTrue(d.FindDescriptor<FieldDescriptor>("default_int32").HasDefaultValue); + Assert.AreEqual(41, d.FindDescriptor<FieldDescriptor>("default_int32").DefaultValue); + + d = TestExtremeDefaultValues.Descriptor; + Assert.AreEqual(ByteString.CopyFrom("\u0000\u0001\u0007\b\f\n\r\t\u000b\\\'\"\u00fe", Encoding.GetEncoding(28591)), + d.FindDescriptor<FieldDescriptor>("escaped_bytes").DefaultValue); + Assert.AreEqual(uint.MaxValue, d.FindDescriptor<FieldDescriptor>("large_uint32").DefaultValue); + Assert.AreEqual(ulong.MaxValue, d.FindDescriptor<FieldDescriptor>("large_uint64").DefaultValue); + } + + [Test] + public void EnumDescriptor() { + // Note: this test is a bit different to the Java version because there's no static way of getting to the descriptor + EnumDescriptor enumType = UnitTestProtoFile.Descriptor.FindTypeByName<EnumDescriptor>("ForeignEnum"); + EnumDescriptor nestedType = TestAllTypes.Descriptor.FindDescriptor<EnumDescriptor>("NestedEnum"); + + Assert.AreEqual("ForeignEnum", enumType.Name); + Assert.AreEqual("protobuf_unittest.ForeignEnum", enumType.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, enumType.File); + Assert.IsNull(enumType.ContainingType); + Assert.AreEqual(DescriptorProtos.EnumOptions.DefaultInstance, + enumType.Options); + + Assert.AreEqual("NestedEnum", nestedType.Name); + Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedEnum", + nestedType.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, nestedType.File); + Assert.AreEqual(TestAllTypes.Descriptor, nestedType.ContainingType); + + EnumValueDescriptor value = enumType.FindValueByName("FOREIGN_FOO"); + Assert.AreEqual(value, enumType.Values[0]); + Assert.AreEqual("FOREIGN_FOO", value.Name); + Assert.AreEqual(4, value.Number); + Assert.AreEqual((int) ForeignEnum.FOREIGN_FOO, value.Number); + Assert.AreEqual(value, enumType.FindValueByNumber(4)); + Assert.IsNull(enumType.FindValueByName("NO_SUCH_VALUE")); + for (int i = 0; i < enumType.Values.Count; i++) { + Assert.AreEqual(i, enumType.Values[i].Index); + } + } + + [Test] + public void ServiceDescriptor() { + ServiceDescriptor service = TestService.Descriptor; + + Assert.AreEqual("TestService", service.Name); + Assert.AreEqual("protobuf_unittest.TestService", service.FullName); + Assert.AreEqual(UnitTestProtoFile.Descriptor, service.File); + + Assert.AreEqual(2, service.Methods.Count); + + MethodDescriptor fooMethod = service.Methods[0]; + Assert.AreEqual("Foo", fooMethod.Name); + Assert.AreEqual(FooRequest.Descriptor, fooMethod.InputType); + Assert.AreEqual(FooResponse.Descriptor, fooMethod.OutputType); + Assert.AreEqual(fooMethod, service.FindMethodByName("Foo")); + + MethodDescriptor barMethod = service.Methods[1]; + Assert.AreEqual("Bar", barMethod.Name); + Assert.AreEqual(BarRequest.Descriptor, barMethod.InputType); + Assert.AreEqual(BarResponse.Descriptor, barMethod.OutputType); + Assert.AreEqual(barMethod, service.FindMethodByName("Bar")); + + Assert.IsNull(service.FindMethodByName("NoSuchMethod")); + + for (int i = 0; i < service.Methods.Count; i++) { + Assert.AreEqual(i, service.Methods[i].Index); + } + } + } +} diff --git a/src/ProtocolBuffers.Test/DynamicMessageTest.cs b/src/ProtocolBuffers.Test/DynamicMessageTest.cs new file mode 100644 index 00000000..11fc2d82 --- /dev/null +++ b/src/ProtocolBuffers.Test/DynamicMessageTest.cs @@ -0,0 +1,114 @@ +using Google.ProtocolBuffers.TestProtos; +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class DynamicMessageTest { + + private ReflectionTester reflectionTester; + private ReflectionTester extensionsReflectionTester; + + [SetUp] + public void SetUp() { + reflectionTester = ReflectionTester.CreateTestAllTypesInstance(); + extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance(); + } + + [Test] + public void DynamicMessageAccessors() { + IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(builder); + IMessage message = builder.WeakBuild(); + reflectionTester.AssertAllFieldsSetViaReflection(message); + } + + [Test] + public void DynamicMessageExtensionAccessors() { + // We don't need to extensively test DynamicMessage's handling of + // extensions because, frankly, it doesn't do anything special with them. + // It treats them just like any other fields. + IBuilder builder = DynamicMessage.CreateBuilder(TestAllExtensions.Descriptor); + extensionsReflectionTester.SetAllFieldsViaReflection(builder); + IMessage message = builder.WeakBuild(); + extensionsReflectionTester.AssertAllFieldsSetViaReflection(message); + } + + [Test] + public void DynamicMessageRepeatedSetters() { + IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(builder); + reflectionTester.ModifyRepeatedFieldsViaReflection(builder); + IMessage message = builder.WeakBuild(); + reflectionTester.AssertRepeatedFieldsModifiedViaReflection(message); + } + + [Test] + public void DynamicMessageDefaults() { + reflectionTester.AssertClearViaReflection(DynamicMessage.GetDefaultInstance(TestAllTypes.Descriptor)); + reflectionTester.AssertClearViaReflection(DynamicMessage.CreateBuilder(TestAllTypes.Descriptor).Build()); + } + + [Test] + public void DynamicMessageSerializedSize() { + TestAllTypes message = TestUtil.GetAllSet(); + + IBuilder dynamicBuilder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(dynamicBuilder); + IMessage dynamicMessage = dynamicBuilder.WeakBuild(); + + Assert.AreEqual(message.SerializedSize, dynamicMessage.SerializedSize); + } + + [Test] + public void DynamicMessageSerialization() { + IBuilder builder = DynamicMessage.CreateBuilder(TestAllTypes.Descriptor); + reflectionTester.SetAllFieldsViaReflection(builder); + IMessage message = builder.WeakBuild(); + + ByteString rawBytes = message.ToByteString(); + TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); + + TestUtil.AssertAllFieldsSet(message2); + + // In fact, the serialized forms should be exactly the same, byte-for-byte. + Assert.AreEqual(TestUtil.GetAllSet().ToByteString(), rawBytes); + } + + [Test] + public void DynamicMessageParsing() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestAllTypes message = builder.Build(); + + ByteString rawBytes = message.ToByteString(); + + IMessage message2 = DynamicMessage.ParseFrom(TestAllTypes.Descriptor, rawBytes); + reflectionTester.AssertAllFieldsSetViaReflection(message2); + } + + [Test] + public void DynamicMessageCopy() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestAllTypes message = builder.Build(); + + DynamicMessage copy = DynamicMessage.CreateBuilder(message).Build(); + reflectionTester.AssertAllFieldsSetViaReflection(copy); + } + } +} diff --git a/src/ProtocolBuffers.Test/GeneratedMessageTest.cs b/src/ProtocolBuffers.Test/GeneratedMessageTest.cs new file mode 100644 index 00000000..feba6e3b --- /dev/null +++ b/src/ProtocolBuffers.Test/GeneratedMessageTest.cs @@ -0,0 +1,291 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class GeneratedMessageTest { + ReflectionTester reflectionTester; + ReflectionTester extensionsReflectionTester; + + [SetUp] + public void SetUp() { + reflectionTester = ReflectionTester.CreateTestAllTypesInstance(); + extensionsReflectionTester = ReflectionTester.CreateTestAllExtensionsInstance(); + } + + [Test] + public void RepeatedAddPrimitiveBeforeBuild() { + TestAllTypes message = new TestAllTypes.Builder { RepeatedInt32List = { 1, 2, 3 } }.Build(); + TestUtil.AssertEqual(new int[]{1, 2, 3}, message.RepeatedInt32List); + } + + [Test] + public void AddPrimitiveFailsAfterBuild() { + TestAllTypes.Builder builder = new TestAllTypes.Builder(); + IList<int> list = builder.RepeatedInt32List; + list.Add(1); // Fine + builder.Build(); + + try { + list.Add(2); + Assert.Fail("List should be frozen"); + } catch (NotSupportedException) { + // Expected + } + } + + [Test] + public void RepeatedAddMessageBeforeBuild() { + TestAllTypes message = new TestAllTypes.Builder { + RepeatedNestedMessageList = { new TestAllTypes.Types.NestedMessage.Builder { Bb = 10 }.Build() } }.Build(); + Assert.AreEqual(1, message.RepeatedNestedMessageCount); + Assert.AreEqual(10, message.RepeatedNestedMessageList[0].Bb); + } + + [Test] + public void AddMessageFailsAfterBuild() { + TestAllTypes.Builder builder = new TestAllTypes.Builder(); + IList<TestAllTypes.Types.NestedMessage> list = builder.RepeatedNestedMessageList; + builder.Build(); + + try { + list.Add(new TestAllTypes.Types.NestedMessage.Builder { Bb = 10 }.Build()); + Assert.Fail("List should be frozen"); + } catch (NotSupportedException) { + // Expected + } + } + + [Test] + public void DefaultInstance() { + Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.DefaultInstance.DefaultInstanceForType); + Assert.AreSame(TestAllTypes.DefaultInstance, TestAllTypes.CreateBuilder().DefaultInstanceForType); + } + + [Test] + public void Accessors() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestAllTypes message = builder.Build(); + TestUtil.AssertAllFieldsSet(message); + } + + [Test] + public void RepeatedSetters() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestUtil.ModifyRepeatedFields(builder); + TestAllTypes message = builder.Build(); + TestUtil.AssertRepeatedFieldsModified(message); + } + + [Test] + public void RepeatedAppend() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + + builder.AddRangeRepeatedInt32(new int[]{1, 2, 3, 4}); + builder.AddRangeRepeatedForeignEnum((new ForeignEnum[] { ForeignEnum.FOREIGN_BAZ })); + + ForeignMessage foreignMessage = ForeignMessage.CreateBuilder().SetC(12).Build(); + builder.AddRangeRepeatedForeignMessage(new ForeignMessage[] {foreignMessage}); + + TestAllTypes message = builder.Build(); + TestUtil.AssertEqual(message.RepeatedInt32List, new int[]{1, 2, 3, 4}); + TestUtil.AssertEqual(message.RepeatedForeignEnumList, new ForeignEnum[] {ForeignEnum.FOREIGN_BAZ}); + Assert.AreEqual(1, message.RepeatedForeignMessageCount); + Assert.AreEqual(12, message.GetRepeatedForeignMessage(0).C); + } + + [Test] + public void SettingForeignMessageUsingBuilder() { + TestAllTypes message = TestAllTypes.CreateBuilder() + // Pass builder for foreign message instance. + .SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(123)) + .Build(); + TestAllTypes expectedMessage = TestAllTypes.CreateBuilder() + // Create expected version passing foreign message instance explicitly. + .SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(123).Build()) + .Build(); + Assert.AreEqual(expectedMessage, message); + } + + [Test] + public void SettingRepeatedForeignMessageUsingBuilder() { + TestAllTypes message = TestAllTypes.CreateBuilder() + // Pass builder for foreign message instance. + .AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(456)) + .Build(); + TestAllTypes expectedMessage = TestAllTypes.CreateBuilder() + // Create expected version passing foreign message instance explicitly. + .AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(456).Build()) + .Build(); + Assert.AreEqual(expectedMessage, message); + } + + + [Test] + public void Defaults() { + TestUtil.AssertClear(TestAllTypes.DefaultInstance); + TestUtil.AssertClear(TestAllTypes.CreateBuilder().Build()); + + Assert.AreEqual("\u1234", TestExtremeDefaultValues.DefaultInstance.Utf8String); + } + + [Test] + public void ReflectionGetters() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TestUtil.SetAllFields(builder); + TestAllTypes message = builder.Build(); + reflectionTester.AssertAllFieldsSetViaReflection(message); + } + + [Test] + public void ReflectionSetters() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + reflectionTester.SetAllFieldsViaReflection(builder); + TestAllTypes message = builder.Build(); + TestUtil.AssertAllFieldsSet(message); + } + + [Test] + public void ReflectionRepeatedSetters() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + reflectionTester.SetAllFieldsViaReflection(builder); + reflectionTester.ModifyRepeatedFieldsViaReflection(builder); + TestAllTypes message = builder.Build(); + TestUtil.AssertRepeatedFieldsModified(message); + } + + [Test] + public void ReflectionDefaults() { + reflectionTester.AssertClearViaReflection(TestAllTypes.DefaultInstance); + reflectionTester.AssertClearViaReflection(TestAllTypes.CreateBuilder().Build()); + } + // ================================================================= + // Extensions. + + [Test] + public void ExtensionAccessors() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + TestUtil.SetAllExtensions(builder); + TestAllExtensions message = builder.Build(); + TestUtil.AssertAllExtensionsSet(message); + } + + [Test] + public void ExtensionRepeatedSetters() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + TestUtil.SetAllExtensions(builder); + TestUtil.ModifyRepeatedExtensions(builder); + TestAllExtensions message = builder.Build(); + TestUtil.AssertRepeatedExtensionsModified(message); + } + + [Test] + public void ExtensionDefaults() { + TestUtil.AssertExtensionsClear(TestAllExtensions.DefaultInstance); + TestUtil.AssertExtensionsClear(TestAllExtensions.CreateBuilder().Build()); + } + + [Test] + public void ExtensionReflectionGetters() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + TestUtil.SetAllExtensions(builder); + TestAllExtensions message = builder.Build(); + extensionsReflectionTester.AssertAllFieldsSetViaReflection(message); + } + + [Test] + public void ExtensionReflectionSetters() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + extensionsReflectionTester.SetAllFieldsViaReflection(builder); + TestAllExtensions message = builder.Build(); + TestUtil.AssertAllExtensionsSet(message); + } + + [Test] + public void ExtensionReflectionRepeatedSetters() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + extensionsReflectionTester.SetAllFieldsViaReflection(builder); + extensionsReflectionTester.ModifyRepeatedFieldsViaReflection(builder); + TestAllExtensions message = builder.Build(); + TestUtil.AssertRepeatedExtensionsModified(message); + } + + [Test] + public void ExtensionReflectionDefaults() { + extensionsReflectionTester.AssertClearViaReflection(TestAllExtensions.DefaultInstance); + extensionsReflectionTester.AssertClearViaReflection(TestAllExtensions.CreateBuilder().Build()); + } + + [Test] + public void ClearExtension() { + // ClearExtension() is not actually used in TestUtil, so try it manually. + Assert.IsFalse(TestAllExtensions.CreateBuilder() + .SetExtension(UnitTestProtoFile.OptionalInt32Extension, 1) + .ClearExtension(UnitTestProtoFile.OptionalInt32Extension) + .HasExtension(UnitTestProtoFile.OptionalInt32Extension)); + Assert.AreEqual(0, TestAllExtensions.CreateBuilder() + .AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 1) + .ClearExtension(UnitTestProtoFile.RepeatedInt32Extension) + .GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension)); + } + + /* Removed multiple files option for the moment + [Test] + public void MultipleFilesOption() { + // We mostly just want to check that things compile. + MessageWithNoOuter message = MessageWithNoOuter.CreateBuilder() + .SetNested(MessageWithNoOuter.Types.NestedMessage.CreateBuilder().SetI(1)) + .AddForeign(TestAllTypes.CreateBuilder().SetOptionalInt32(1)) + .SetNestedEnum(MessageWithNoOuter.Types.NestedEnum.BAZ) + .SetForeignEnum(EnumWithNoOuter.BAR) + .Build(); + Assert.AreEqual(message, MessageWithNoOuter.ParseFrom(message.ToByteString())); + + Assert.AreEqual(MultiFileProto.Descriptor, MessageWithNoOuter.Descriptor.File); + + FieldDescriptor field = MessageWithNoOuter.Descriptor.FindDescriptor<FieldDescriptor>("foreign_enum"); + Assert.AreEqual(MultiFileProto.Descriptor.FindTypeByName<EnumDescriptor>("EnumWithNoOuter") + .FindValueByNumber((int)EnumWithNoOuter.BAR), message[field]); + + Assert.AreEqual(MultiFileProto.Descriptor, ServiceWithNoOuter.Descriptor.File); + + Assert.IsFalse(TestAllExtensions.DefaultInstance.HasExtension(MultiFileProto.ExtensionWithOuter)); + }*/ + + [Test] + public void OptionalFieldWithRequiredSubfieldsOptimizedForSize() { + TestOptionalOptimizedForSize message = TestOptionalOptimizedForSize.DefaultInstance; + Assert.IsTrue(message.IsInitialized); + + message = TestOptionalOptimizedForSize.CreateBuilder().SetO( + TestRequiredOptimizedForSize.CreateBuilder().BuildPartial() + ).BuildPartial(); + Assert.IsFalse(message.IsInitialized); + + message = TestOptionalOptimizedForSize.CreateBuilder().SetO( + TestRequiredOptimizedForSize.CreateBuilder().SetX(5).BuildPartial() + ).BuildPartial(); + Assert.IsTrue(message.IsInitialized); + } + } +} diff --git a/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs b/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs new file mode 100644 index 00000000..0cccd4a7 --- /dev/null +++ b/src/ProtocolBuffers.Test/MessageStreamIteratorTest.cs @@ -0,0 +1,23 @@ +using System.Collections; +using System.Collections.Generic; +using System.IO; +using NUnit.Framework; +using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class MessageStreamIteratorTest { + + [Test] + public void ThreeMessagesInMemory() { + MemoryStream stream = new MemoryStream(MessageStreamWriterTest.ThreeMessageData); + IEnumerable<NestedMessage> iterator = MessageStreamIterator<NestedMessage>.FromStreamProvider(() => stream); + List<NestedMessage> messages = new List<NestedMessage>(iterator); + + Assert.AreEqual(3, messages.Count); + Assert.AreEqual(5, messages[0].Bb); + Assert.AreEqual(1500, messages[1].Bb); + Assert.IsFalse(messages[2].HasBb); + } + } +} diff --git a/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs b/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs new file mode 100644 index 00000000..9cbe2b33 --- /dev/null +++ b/src/ProtocolBuffers.Test/MessageStreamWriterTest.cs @@ -0,0 +1,36 @@ +using System.IO; +using NUnit.Framework; +using NestedMessage = Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class MessageStreamWriterTest { + + internal static readonly byte[] ThreeMessageData = new byte[] { + (1 << 3) | 2, 2, // Field 1, 2 bytes long (first message) + (1 << 3) | 0, 5, // Field 1, value 5 + (1 << 3) | 2, 3, // Field 1, 3 bytes long (second message) + (1 << 3) | 0, (1500 & 0x7f) | 0x80, 1500 >> 7, // Field 1, value 1500 + (1 << 3) | 2, 0, // Field 1, no data (third message) + }; + + [Test] + public void ThreeMessages() { + NestedMessage message1 = new NestedMessage.Builder { Bb = 5 }.Build(); + NestedMessage message2 = new NestedMessage.Builder { Bb = 1500 }.Build(); + NestedMessage message3 = new NestedMessage.Builder().Build(); + + byte[] data; + using (MemoryStream stream = new MemoryStream()) { + MessageStreamWriter<NestedMessage> writer = new MessageStreamWriter<NestedMessage>(stream); + writer.Write(message1); + writer.Write(message2); + writer.Write(message3); + writer.Flush(); + data = stream.ToArray(); + } + + TestUtil.AssertEqualBytes(ThreeMessageData, data); + } + } +} diff --git a/src/ProtocolBuffers.Test/MessageTest.cs b/src/ProtocolBuffers.Test/MessageTest.cs new file mode 100644 index 00000000..d206e78f --- /dev/null +++ b/src/ProtocolBuffers.Test/MessageTest.cs @@ -0,0 +1,299 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Miscellaneous tests for message operations that apply to both + /// generated and dynamic messages. + /// </summary> + [TestFixture] + public class MessageTest { + // ================================================================= + // Message-merging tests. + + private static readonly TestAllTypes MergeSource = new TestAllTypes.Builder { + OptionalInt32 = 1, + OptionalString = "foo", + OptionalForeignMessage = ForeignMessage.DefaultInstance, + }.AddRepeatedString("bar").Build(); + + private static readonly TestAllTypes MergeDest = new TestAllTypes.Builder { + OptionalInt64 = 2, + OptionalString = "baz", + OptionalForeignMessage = new ForeignMessage.Builder { C=3 }.Build(), + }.AddRepeatedString("qux").Build(); + + private const string MergeResultText = + "optional_int32: 1\n" + + "optional_int64: 2\n" + + "optional_string: \"foo\"\n" + + "optional_foreign_message {\n" + + " c: 3\n" + + "}\n" + + "repeated_string: \"qux\"\n" + + "repeated_string: \"bar\"\n"; + + [Test] + public void MergeFrom() { + TestAllTypes result = TestAllTypes.CreateBuilder(MergeDest).MergeFrom(MergeSource).Build(); + + Assert.AreEqual(MergeResultText, result.ToString()); + } + + /// <summary> + /// Test merging a DynamicMessage into a GeneratedMessage. + /// As long as they have the same descriptor, this should work, but it is an + /// entirely different code path. + /// </summary> + [Test] + public void MergeFromDynamic() { + TestAllTypes result = (TestAllTypes) TestAllTypes.CreateBuilder(MergeDest) + .MergeFrom(DynamicMessage.CreateBuilder(MergeSource).Build()) + .Build(); + + Assert.AreEqual(MergeResultText, result.ToString()); + } + + /// <summary> + /// Test merging two DynamicMessages. + /// </summary> + [Test] + public void DynamicMergeFrom() { + DynamicMessage result = (DynamicMessage) DynamicMessage.CreateBuilder(MergeDest) + .MergeFrom((DynamicMessage) DynamicMessage.CreateBuilder(MergeSource).Build()) + .Build(); + + Assert.AreEqual(MergeResultText, result.ToString()); + } + + // ================================================================= + // Required-field-related tests. + + private static readonly TestRequired TestRequiredUninitialized = TestRequired.DefaultInstance; + private static readonly TestRequired TestRequiredInitialized = new TestRequired.Builder { + A = 1, B = 2, C = 3 + }.Build(); + + [Test] + public void Initialization() { + TestRequired.Builder builder = TestRequired.CreateBuilder(); + + Assert.IsFalse(builder.IsInitialized); + builder.A = 1; + Assert.IsFalse(builder.IsInitialized); + builder.B = 1; + Assert.IsFalse(builder.IsInitialized); + builder.C = 1; + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void RequiredForeign() { + TestRequiredForeign.Builder builder = TestRequiredForeign.CreateBuilder(); + + Assert.IsTrue(builder.IsInitialized); + + builder.SetOptionalMessage(TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetOptionalMessage(TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + + builder.AddRepeatedMessage(TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetRepeatedMessage(0, TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void RequiredExtension() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + + Assert.IsTrue(builder.IsInitialized); + + builder.SetExtension(TestRequired.Single, TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetExtension(TestRequired.Single, TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + + builder.AddExtension(TestRequired.Multi, TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetExtension(TestRequired.Multi, 0, TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void RequiredDynamic() { + MessageDescriptor descriptor = TestRequired.Descriptor; + DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor); + + Assert.IsFalse(builder.IsInitialized); + builder[descriptor.FindDescriptor<FieldDescriptor>("a")] = 1; + Assert.IsFalse(builder.IsInitialized); + builder[descriptor.FindDescriptor<FieldDescriptor>("b")] = 1; + Assert.IsFalse(builder.IsInitialized); + builder[descriptor.FindDescriptor<FieldDescriptor>("c")] = 1; + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void RequiredDynamicForeign() { + MessageDescriptor descriptor = TestRequiredForeign.Descriptor; + DynamicMessage.Builder builder = DynamicMessage.CreateBuilder(descriptor); + + Assert.IsTrue(builder.IsInitialized); + + builder[descriptor.FindDescriptor<FieldDescriptor>("optional_message")] = TestRequiredUninitialized; + Assert.IsFalse(builder.IsInitialized); + + builder[descriptor.FindDescriptor<FieldDescriptor>("optional_message")] = TestRequiredInitialized; + Assert.IsTrue(builder.IsInitialized); + + builder.AddRepeatedField(descriptor.FindDescriptor<FieldDescriptor>("repeated_message"), TestRequiredUninitialized); + Assert.IsFalse(builder.IsInitialized); + + builder.SetRepeatedField(descriptor.FindDescriptor<FieldDescriptor>("repeated_message"), 0, TestRequiredInitialized); + Assert.IsTrue(builder.IsInitialized); + } + + [Test] + public void UninitializedException() { + try { + TestRequired.CreateBuilder().Build(); + Assert.Fail("Should have thrown an exception."); + } catch (UninitializedMessageException e) { + Assert.AreEqual("Message missing required fields: a, b, c", e.Message); + } + } + + [Test] + public void BuildPartial() { + // We're mostly testing that no exception is thrown. + TestRequired message = TestRequired.CreateBuilder().BuildPartial(); + Assert.IsFalse(message.IsInitialized); + } + + [Test] + public void NestedUninitializedException() { + try { + TestRequiredForeign.CreateBuilder() + .SetOptionalMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .Build(); + Assert.Fail("Should have thrown an exception."); + } catch (UninitializedMessageException e) { + Assert.AreEqual( + "Message missing required fields: " + + "optional_message.a, " + + "optional_message.b, " + + "optional_message.c, " + + "repeated_message[0].a, " + + "repeated_message[0].b, " + + "repeated_message[0].c, " + + "repeated_message[1].a, " + + "repeated_message[1].b, " + + "repeated_message[1].c", + e.Message); + } + } + + [Test] + public void BuildNestedPartial() { + // We're mostly testing that no exception is thrown. + TestRequiredForeign message = + TestRequiredForeign.CreateBuilder() + .SetOptionalMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .BuildPartial(); + Assert.IsFalse(message.IsInitialized); + } + + [Test] + public void ParseUnititialized() { + try { + TestRequired.ParseFrom(ByteString.Empty); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual("Message missing required fields: a, b, c", e.Message); + } + } + + [Test] + public void ParseNestedUnititialized() { + ByteString data = + TestRequiredForeign.CreateBuilder() + .SetOptionalMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .AddRepeatedMessage(TestRequiredUninitialized) + .BuildPartial().ToByteString(); + + try { + TestRequiredForeign.ParseFrom(data); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual( + "Message missing required fields: " + + "optional_message.a, " + + "optional_message.b, " + + "optional_message.c, " + + "repeated_message[0].a, " + + "repeated_message[0].b, " + + "repeated_message[0].c, " + + "repeated_message[1].a, " + + "repeated_message[1].b, " + + "repeated_message[1].c", + e.Message); + } + } + + [Test] + public void DynamicUninitializedException() { + try { + DynamicMessage.CreateBuilder(TestRequired.Descriptor).Build(); + Assert.Fail("Should have thrown an exception."); + } catch (UninitializedMessageException e) { + Assert.AreEqual("Message missing required fields: a, b, c", e.Message); + } + } + + [Test] + public void DynamicBuildPartial() { + // We're mostly testing that no exception is thrown. + DynamicMessage message = DynamicMessage.CreateBuilder(TestRequired.Descriptor).BuildPartial(); + Assert.IsFalse(message.Initialized); + } + + [Test] + public void DynamicParseUnititialized() { + try { + MessageDescriptor descriptor = TestRequired.Descriptor; + DynamicMessage.ParseFrom(descriptor, ByteString.Empty); + Assert.Fail("Should have thrown an exception."); + } catch (InvalidProtocolBufferException e) { + Assert.AreEqual("Message missing required fields: a, b, c", e.Message); + } + } + } + +} diff --git a/src/ProtocolBuffers.Test/Properties/AssemblyInfo.cs b/src/ProtocolBuffers.Test/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..93ff802f --- /dev/null +++ b/src/ProtocolBuffers.Test/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtocolBuffers.Test")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtocolBuffers.Test")] +[assembly: AssemblyCopyright("Copyright © 2008")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("54e627c3-daaa-4850-82cf-f25b7f097e78")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/ProtocolBuffers.Test/Properties/Google.ProtocolBuffers.Test.snk b/src/ProtocolBuffers.Test/Properties/Google.ProtocolBuffers.Test.snk Binary files differnew file mode 100644 index 00000000..20046fb2 --- /dev/null +++ b/src/ProtocolBuffers.Test/Properties/Google.ProtocolBuffers.Test.snk diff --git a/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj new file mode 100644 index 00000000..7f84da07 --- /dev/null +++ b/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -0,0 +1,88 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProductVersion>9.0.30729</ProductVersion> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{DD01ED24-3750-4567-9A23-1DB676A15610}</ProjectGuid> + <OutputType>Library</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>Google.ProtocolBuffers</RootNamespace> + <AssemblyName>Google.ProtocolBuffers.Test</AssemblyName> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + <SignAssembly>true</SignAssembly> + <AssemblyOriginatorKeyFile>Properties\Google.ProtocolBuffers.Test.snk</AssemblyOriginatorKeyFile> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <ItemGroup> + <Reference Include="nunit.framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77"> + <SpecificVersion>False</SpecificVersion> + <HintPath>..\..\lib\nunit.framework.dll</HintPath> + </Reference> + <Reference Include="Rhino.Mocks, Version=3.5.0.2, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL"> + <SpecificVersion>False</SpecificVersion> + <HintPath>..\..\lib\Rhino.Mocks.dll</HintPath> + </Reference> + <Reference Include="System" /> + </ItemGroup> + <ItemGroup> + <Compile Include="AbstractMessageTest.cs" /> + <Compile Include="ByteStringTest.cs" /> + <Compile Include="CodedInputStreamTest.cs" /> + <Compile Include="CodedOutputStreamTest.cs" /> + <Compile Include="Collections\PopsicleListTest.cs" /> + <Compile Include="DescriptorsTest.cs" /> + <Compile Include="DynamicMessageTest.cs" /> + <Compile Include="GeneratedMessageTest.cs" /> + <Compile Include="MessageStreamIteratorTest.cs" /> + <Compile Include="MessageStreamWriterTest.cs" /> + <Compile Include="MessageTest.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + <Compile Include="ReflectionTester.cs" /> + <Compile Include="ServiceTest.cs" /> + <Compile Include="TestProtos\UnitTestEmbedOptimizeForProtoFile.cs" /> + <Compile Include="TestProtos\UnitTestImportProtoFile.cs" /> + <Compile Include="TestProtos\UnitTestMessageSetProtoFile.cs" /> + <Compile Include="TestProtos\UnitTestOptimizeForProtoFile.cs" /> + <Compile Include="TestProtos\UnitTestProtoFile.cs" /> + <Compile Include="TestUtil.cs" /> + <Compile Include="TextFormatTest.cs" /> + <Compile Include="UnknownFieldSetTest.cs" /> + <Compile Include="WireFormatTest.cs" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj"> + <Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project> + <Name>ProtocolBuffers</Name> + </ProjectReference> + </ItemGroup> + <ItemGroup> + <None Include="Properties\Google.ProtocolBuffers.Test.snk" /> + </ItemGroup> + <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> + <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + --> +</Project>
\ No newline at end of file diff --git a/src/ProtocolBuffers.Test/ReflectionTester.cs b/src/ProtocolBuffers.Test/ReflectionTester.cs new file mode 100644 index 00000000..c146a823 --- /dev/null +++ b/src/ProtocolBuffers.Test/ReflectionTester.cs @@ -0,0 +1,798 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Performs the same things that the methods of TestUtil do, but + /// via the reflection interface. This is its own class because it needs + /// to know what descriptor to use. + /// </summary> + internal class ReflectionTester { + private readonly MessageDescriptor baseDescriptor; + private readonly ExtensionRegistry extensionRegistry; + + private readonly FileDescriptor file; + private readonly FileDescriptor importFile; + + private readonly MessageDescriptor optionalGroup; + private readonly MessageDescriptor repeatedGroup; + private readonly MessageDescriptor nestedMessage; + private readonly MessageDescriptor foreignMessage; + private readonly MessageDescriptor importMessage; + + private readonly FieldDescriptor groupA; + private readonly FieldDescriptor repeatedGroupA; + private readonly FieldDescriptor nestedB; + private readonly FieldDescriptor foreignC; + private readonly FieldDescriptor importD; + + private readonly EnumDescriptor nestedEnum; + private readonly EnumDescriptor foreignEnum; + private readonly EnumDescriptor importEnum; + + private readonly EnumValueDescriptor nestedFoo; + private readonly EnumValueDescriptor nestedBar; + private readonly EnumValueDescriptor nestedBaz; + private readonly EnumValueDescriptor foreignFoo; + private readonly EnumValueDescriptor foreignBar; + private readonly EnumValueDescriptor foreignBaz; + private readonly EnumValueDescriptor importFoo; + private readonly EnumValueDescriptor importBar; + private readonly EnumValueDescriptor importBaz; + + /// <summary> + /// Constructs an instance that will expect messages using the given + /// descriptor. Normally <paramref name="baseDescriptor"/> should be + /// a descriptor for TestAllTypes. However, if extensionRegistry is non-null, + /// then baseDescriptor should be for TestAllExtensions instead, and instead of + /// reading and writing normal fields, the tester will read and write extensions. + /// All of the TestAllExtensions extensions must be registered in the registry. + /// </summary> + private ReflectionTester(MessageDescriptor baseDescriptor, + ExtensionRegistry extensionRegistry) { + this.baseDescriptor = baseDescriptor; + this.extensionRegistry = extensionRegistry; + + this.file = baseDescriptor.File; + // TODO(jonskeet): We've got 3 dependencies, not 1 - because of the C# options. Hmm. +// Assert.AreEqual(1, file.Dependencies.Count); + // TODO(jonskeet): Find dependency by name instead of number? + this.importFile = file.Dependencies[2]; + + MessageDescriptor testAllTypes; + if (extensionRegistry == null) { + testAllTypes = baseDescriptor; + } else { + testAllTypes = file.FindTypeByName<MessageDescriptor>("TestAllTypes"); + Assert.IsNotNull(testAllTypes); + } + + if (extensionRegistry == null) { + this.optionalGroup = + baseDescriptor.FindDescriptor<MessageDescriptor>("OptionalGroup"); + this.repeatedGroup = + baseDescriptor.FindDescriptor<MessageDescriptor>("RepeatedGroup"); + } else { + this.optionalGroup = + file.FindTypeByName<MessageDescriptor>("OptionalGroup_extension"); + this.repeatedGroup = + file.FindTypeByName<MessageDescriptor>("RepeatedGroup_extension"); + } + this.nestedMessage = testAllTypes.FindDescriptor<MessageDescriptor>("NestedMessage"); + this.foreignMessage = file.FindTypeByName<MessageDescriptor>("ForeignMessage"); + this.importMessage = importFile.FindTypeByName<MessageDescriptor>("ImportMessage"); + + this.nestedEnum = testAllTypes.FindDescriptor<EnumDescriptor>("NestedEnum"); + this.foreignEnum = file.FindTypeByName<EnumDescriptor>("ForeignEnum"); + this.importEnum = importFile.FindTypeByName<EnumDescriptor>("ImportEnum"); + + Assert.IsNotNull(optionalGroup ); + Assert.IsNotNull(repeatedGroup ); + Assert.IsNotNull(nestedMessage ); + Assert.IsNotNull(foreignMessage); + Assert.IsNotNull(importMessage ); + Assert.IsNotNull(nestedEnum ); + Assert.IsNotNull(foreignEnum ); + Assert.IsNotNull(importEnum ); + + this.nestedB = nestedMessage.FindDescriptor<FieldDescriptor>("bb"); + this.foreignC = foreignMessage.FindDescriptor<FieldDescriptor>("c"); + this.importD = importMessage .FindDescriptor<FieldDescriptor>("d"); + this.nestedFoo = nestedEnum.FindValueByName("FOO"); + this.nestedBar = nestedEnum.FindValueByName("BAR"); + this.nestedBaz = nestedEnum.FindValueByName("BAZ"); + this.foreignFoo = foreignEnum.FindValueByName("FOREIGN_FOO"); + this.foreignBar = foreignEnum.FindValueByName("FOREIGN_BAR"); + this.foreignBaz = foreignEnum.FindValueByName("FOREIGN_BAZ"); + this.importFoo = importEnum.FindValueByName("IMPORT_FOO"); + this.importBar = importEnum.FindValueByName("IMPORT_BAR"); + this.importBaz = importEnum.FindValueByName("IMPORT_BAZ"); + + this.groupA = optionalGroup.FindDescriptor<FieldDescriptor>("a"); + this.repeatedGroupA = repeatedGroup.FindDescriptor<FieldDescriptor>("a"); + + Assert.IsNotNull(groupA ); + Assert.IsNotNull(repeatedGroupA); + Assert.IsNotNull(nestedB ); + Assert.IsNotNull(foreignC ); + Assert.IsNotNull(importD ); + Assert.IsNotNull(nestedFoo ); + Assert.IsNotNull(nestedBar ); + Assert.IsNotNull(nestedBaz ); + Assert.IsNotNull(foreignFoo ); + Assert.IsNotNull(foreignBar ); + Assert.IsNotNull(foreignBaz ); + Assert.IsNotNull(importFoo ); + Assert.IsNotNull(importBar ); + Assert.IsNotNull(importBaz ); + } + + /// <summary> + /// Creates an instance for the TestAllTypes message, with no extension registry. + /// </summary> + public static ReflectionTester CreateTestAllTypesInstance() { + return new ReflectionTester(TestAllTypes.Descriptor, null); + } + + /// <summary> + /// Creates an instance for the TestAllExtensions message, with an + /// extension registry from TestUtil.CreateExtensionRegistry. + /// </summary> + public static ReflectionTester CreateTestAllExtensionsInstance() { + return new ReflectionTester(TestAllExtensions.Descriptor, TestUtil.CreateExtensionRegistry()); + } + + /// <summary> + /// Shorthand to get a FieldDescriptor for a field of unittest::TestAllTypes. + /// </summary> + private FieldDescriptor f(String name) { + FieldDescriptor result; + if (extensionRegistry == null) { + result = baseDescriptor.FindDescriptor<FieldDescriptor>(name); + } else { + result = file.FindTypeByName<FieldDescriptor>(name + "_extension"); + } + Assert.IsNotNull(result); + return result; + } + + /// <summary> + /// Calls parent.CreateBuilderForField() or uses the extension registry + /// to find an appropriate builder, depending on what type is being tested. + /// </summary> + private IBuilder CreateBuilderForField(IBuilder parent, FieldDescriptor field) { + if (extensionRegistry == null) { + return parent.CreateBuilderForField(field); + } else { + ExtensionInfo extension = extensionRegistry[field.ContainingType, field.FieldNumber]; + Assert.IsNotNull(extension); + Assert.IsNotNull(extension.DefaultInstance); + return extension.DefaultInstance.WeakCreateBuilderForType(); + } + } + + /// <summary> + /// Sets every field of the message to the values expected by + /// AssertAllFieldsSet, using the reflection interface. + /// </summary> + /// <param name="message"></param> + internal void SetAllFieldsViaReflection(IBuilder message) { + message[f("optional_int32" )] = 101 ; + message[f("optional_int64" )] = 102L; + message[f("optional_uint32" )] = 103U ; + message[f("optional_uint64" )] = 104UL; + message[f("optional_sint32" )] = 105 ; + message[f("optional_sint64" )] = 106L; + message[f("optional_fixed32" )] = 107U ; + message[f("optional_fixed64" )] = 108UL; + message[f("optional_sfixed32")] = 109 ; + message[f("optional_sfixed64")] = 110L; + message[f("optional_float" )] = 111F; + message[f("optional_double" )] = 112D; + message[f("optional_bool" )] = true; + message[f("optional_string" )] = "115"; + message[f("optional_bytes")] = TestUtil.ToBytes("116"); + + message[f("optionalgroup")] = CreateBuilderForField(message, f("optionalgroup")).SetField(groupA, 117).WeakBuild(); + message[f("optional_nested_message")] = CreateBuilderForField(message, f("optional_nested_message")).SetField(nestedB, 118).WeakBuild(); + message[f("optional_foreign_message")] = CreateBuilderForField(message, f("optional_foreign_message")).SetField(foreignC, 119).WeakBuild(); + message[f("optional_import_message")] = CreateBuilderForField(message, f("optional_import_message")).SetField(importD, 120).WeakBuild(); + + message[f("optional_nested_enum" )] = nestedBaz; + message[f("optional_foreign_enum")] = foreignBaz; + message[f("optional_import_enum" )] = importBaz; + + message[f("optional_string_piece" )] = "124"; + message[f("optional_cord" )] = "125"; + + // ----------------------------------------------------------------- + + message.WeakAddRepeatedField(f("repeated_int32" ), 201 ); + message.WeakAddRepeatedField(f("repeated_int64" ), 202L); + message.WeakAddRepeatedField(f("repeated_uint32" ), 203U ); + message.WeakAddRepeatedField(f("repeated_uint64" ), 204UL); + message.WeakAddRepeatedField(f("repeated_sint32" ), 205 ); + message.WeakAddRepeatedField(f("repeated_sint64" ), 206L); + message.WeakAddRepeatedField(f("repeated_fixed32" ), 207U ); + message.WeakAddRepeatedField(f("repeated_fixed64" ), 208UL); + message.WeakAddRepeatedField(f("repeated_sfixed32"), 209 ); + message.WeakAddRepeatedField(f("repeated_sfixed64"), 210L); + message.WeakAddRepeatedField(f("repeated_float" ), 211F); + message.WeakAddRepeatedField(f("repeated_double" ), 212D); + message.WeakAddRepeatedField(f("repeated_bool" ), true); + message.WeakAddRepeatedField(f("repeated_string" ), "215"); + message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("216")); + + + message.WeakAddRepeatedField(f("repeatedgroup"), CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 217).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_nested_message"), CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 218).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_foreign_message"), CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 219).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_import_message"), CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 220).WeakBuild()); + + message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBar); + message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBar); + message.WeakAddRepeatedField(f("repeated_import_enum" ), importBar); + + message.WeakAddRepeatedField(f("repeated_string_piece" ), "224"); + message.WeakAddRepeatedField(f("repeated_cord" ), "225"); + + // Add a second one of each field. + message.WeakAddRepeatedField(f("repeated_int32" ), 301 ); + message.WeakAddRepeatedField(f("repeated_int64" ), 302L); + message.WeakAddRepeatedField(f("repeated_uint32" ), 303U ); + message.WeakAddRepeatedField(f("repeated_uint64" ), 304UL); + message.WeakAddRepeatedField(f("repeated_sint32" ), 305 ); + message.WeakAddRepeatedField(f("repeated_sint64" ), 306L); + message.WeakAddRepeatedField(f("repeated_fixed32" ), 307U ); + message.WeakAddRepeatedField(f("repeated_fixed64" ), 308UL); + message.WeakAddRepeatedField(f("repeated_sfixed32"), 309 ); + message.WeakAddRepeatedField(f("repeated_sfixed64"), 310L); + message.WeakAddRepeatedField(f("repeated_float" ), 311F); + message.WeakAddRepeatedField(f("repeated_double" ), 312D); + message.WeakAddRepeatedField(f("repeated_bool" ), false); + message.WeakAddRepeatedField(f("repeated_string" ), "315"); + message.WeakAddRepeatedField(f("repeated_bytes" ), TestUtil.ToBytes("316")); + + message.WeakAddRepeatedField(f("repeatedgroup"), + CreateBuilderForField(message, f("repeatedgroup")) + .SetField(repeatedGroupA, 317).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_nested_message"), + CreateBuilderForField(message, f("repeated_nested_message")) + .SetField(nestedB, 318).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_foreign_message"), + CreateBuilderForField(message, f("repeated_foreign_message")) + .SetField(foreignC, 319).WeakBuild()); + message.WeakAddRepeatedField(f("repeated_import_message"), + CreateBuilderForField(message, f("repeated_import_message")) + .SetField(importD, 320).WeakBuild()); + + message.WeakAddRepeatedField(f("repeated_nested_enum" ), nestedBaz); + message.WeakAddRepeatedField(f("repeated_foreign_enum"), foreignBaz); + message.WeakAddRepeatedField(f("repeated_import_enum" ), importBaz); + + message.WeakAddRepeatedField(f("repeated_string_piece" ), "324"); + message.WeakAddRepeatedField(f("repeated_cord" ), "325"); + + // ----------------------------------------------------------------- + + message[f("default_int32" )] = 401 ; + message[f("default_int64" )] = 402L; + message[f("default_uint32" )] = 403U ; + message[f("default_uint64" )] = 404UL; + message[f("default_sint32" )] = 405 ; + message[f("default_sint64" )] = 406L; + message[f("default_fixed32" )] = 407U ; + message[f("default_fixed64" )] = 408UL; + message[f("default_sfixed32")] = 409 ; + message[f("default_sfixed64")] = 410L; + message[f("default_float" )] = 411F; + message[f("default_double" )] = 412D; + message[f("default_bool" )] = false; + message[f("default_string" )] = "415"; + message[f("default_bytes" )] = TestUtil.ToBytes("416"); + + message[f("default_nested_enum" )] = nestedFoo; + message[f("default_foreign_enum")] = foreignFoo; + message[f("default_import_enum" )] = importFoo; + + message[f("default_string_piece" )] = "424"; + message[f("default_cord" )] = "425"; + } + + // ------------------------------------------------------------------- + + /// <summary> + /// Modify the repeated fields of the specified message to contain the + /// values expected by AssertRepeatedFieldsModified, using the IBuilder + /// reflection interface. + /// </summary> + internal void ModifyRepeatedFieldsViaReflection(IBuilder message) { + message[f("repeated_int32" ), 1] = 501 ; + message[f("repeated_int64" ), 1] = 502L; + message[f("repeated_uint32" ), 1] = 503U ; + message[f("repeated_uint64" ), 1] = 504UL; + message[f("repeated_sint32" ), 1] = 505 ; + message[f("repeated_sint64" ), 1] = 506L; + message[f("repeated_fixed32" ), 1] = 507U ; + message[f("repeated_fixed64" ), 1] = 508UL; + message[f("repeated_sfixed32"), 1] = 509 ; + message[f("repeated_sfixed64"), 1] = 510L; + message[f("repeated_float" ), 1] = 511F; + message[f("repeated_double" ), 1] = 512D; + message[f("repeated_bool" ), 1] = true; + message[f("repeated_string" ), 1] = "515"; + message.SetRepeatedField(f("repeated_bytes" ), 1, TestUtil.ToBytes("516")); + + message.SetRepeatedField(f("repeatedgroup"), 1, CreateBuilderForField(message, f("repeatedgroup")).SetField(repeatedGroupA, 517).WeakBuild()); + message.SetRepeatedField(f("repeated_nested_message"), 1, CreateBuilderForField(message, f("repeated_nested_message")).SetField(nestedB, 518).WeakBuild()); + message.SetRepeatedField(f("repeated_foreign_message"), 1, CreateBuilderForField(message, f("repeated_foreign_message")).SetField(foreignC, 519).WeakBuild()); + message.SetRepeatedField(f("repeated_import_message"), 1, CreateBuilderForField(message, f("repeated_import_message")).SetField(importD, 520).WeakBuild()); + + message[f("repeated_nested_enum" ), 1] = nestedFoo; + message[f("repeated_foreign_enum"), 1] = foreignFoo; + message[f("repeated_import_enum" ), 1] = importFoo; + + message[f("repeated_string_piece"), 1] = "524"; + message[f("repeated_cord"), 1] = "525"; + } + + // ------------------------------------------------------------------- + + /// <summary> + /// Asserts that all fields of the specified message are set to the values + /// assigned by SetAllFields, using the IMessage reflection interface. + /// </summary> + public void AssertAllFieldsSetViaReflection(IMessage message) { + Assert.IsTrue(message.HasField(f("optional_int32" ))); + Assert.IsTrue(message.HasField(f("optional_int64" ))); + Assert.IsTrue(message.HasField(f("optional_uint32" ))); + Assert.IsTrue(message.HasField(f("optional_uint64" ))); + Assert.IsTrue(message.HasField(f("optional_sint32" ))); + Assert.IsTrue(message.HasField(f("optional_sint64" ))); + Assert.IsTrue(message.HasField(f("optional_fixed32" ))); + Assert.IsTrue(message.HasField(f("optional_fixed64" ))); + Assert.IsTrue(message.HasField(f("optional_sfixed32"))); + Assert.IsTrue(message.HasField(f("optional_sfixed64"))); + Assert.IsTrue(message.HasField(f("optional_float" ))); + Assert.IsTrue(message.HasField(f("optional_double" ))); + Assert.IsTrue(message.HasField(f("optional_bool" ))); + Assert.IsTrue(message.HasField(f("optional_string" ))); + Assert.IsTrue(message.HasField(f("optional_bytes" ))); + + Assert.IsTrue(message.HasField(f("optionalgroup" ))); + Assert.IsTrue(message.HasField(f("optional_nested_message" ))); + Assert.IsTrue(message.HasField(f("optional_foreign_message"))); + Assert.IsTrue(message.HasField(f("optional_import_message" ))); + + Assert.IsTrue(((IMessage)message[f("optionalgroup")]).HasField(groupA)); + Assert.IsTrue(((IMessage)message[f("optional_nested_message")]).HasField(nestedB)); + Assert.IsTrue(((IMessage)message[f("optional_foreign_message")]).HasField(foreignC)); + Assert.IsTrue(((IMessage)message[f("optional_import_message")]).HasField(importD)); + + Assert.IsTrue(message.HasField(f("optional_nested_enum" ))); + Assert.IsTrue(message.HasField(f("optional_foreign_enum"))); + Assert.IsTrue(message.HasField(f("optional_import_enum" ))); + + Assert.IsTrue(message.HasField(f("optional_string_piece"))); + Assert.IsTrue(message.HasField(f("optional_cord"))); + + Assert.AreEqual(101 , message[f("optional_int32" )]); + Assert.AreEqual(102L , message[f("optional_int64" )]); + Assert.AreEqual(103U , message[f("optional_uint32" )]); + Assert.AreEqual(104UL , message[f("optional_uint64" )]); + Assert.AreEqual(105 , message[f("optional_sint32" )]); + Assert.AreEqual(106L , message[f("optional_sint64" )]); + Assert.AreEqual(107U , message[f("optional_fixed32" )]); + Assert.AreEqual(108UL , message[f("optional_fixed64" )]); + Assert.AreEqual(109 , message[f("optional_sfixed32")]); + Assert.AreEqual(110L , message[f("optional_sfixed64")]); + Assert.AreEqual(111F , message[f("optional_float" )]); + Assert.AreEqual(112D , message[f("optional_double" )]); + Assert.AreEqual(true , message[f("optional_bool" )]); + Assert.AreEqual("115", message[f("optional_string" )]); + Assert.AreEqual(TestUtil.ToBytes("116"), message[f("optional_bytes")]); + + Assert.AreEqual(117,((IMessage)message[f("optionalgroup")])[groupA]); + Assert.AreEqual(118,((IMessage)message[f("optional_nested_message")])[nestedB]); + Assert.AreEqual(119,((IMessage)message[f("optional_foreign_message")])[foreignC]); + Assert.AreEqual(120,((IMessage)message[f("optional_import_message")])[importD]); + + Assert.AreEqual( nestedBaz, message[f("optional_nested_enum" )]); + Assert.AreEqual(foreignBaz, message[f("optional_foreign_enum")]); + Assert.AreEqual( importBaz, message[f("optional_import_enum" )]); + + Assert.AreEqual("124", message[f("optional_string_piece")]); + Assert.AreEqual("125", message[f("optional_cord")]); + + // ----------------------------------------------------------------- + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" ))); + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" ))); + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord"))); + + Assert.AreEqual(201 , message[f("repeated_int32" ), 0]); + Assert.AreEqual(202L , message[f("repeated_int64" ), 0]); + Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]); + Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]); + Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]); + Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]); + Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]); + Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]); + Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]); + Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]); + Assert.AreEqual(211F , message[f("repeated_float" ), 0]); + Assert.AreEqual(212D , message[f("repeated_double" ), 0]); + Assert.AreEqual(true , message[f("repeated_bool" ), 0]); + Assert.AreEqual("215", message[f("repeated_string" ), 0]); + Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]); + + Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]); + Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]); + Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]); + Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]); + + Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]); + Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]); + Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]); + + Assert.AreEqual("224", message[f("repeated_string_piece"), 0]); + Assert.AreEqual("225", message[f("repeated_cord"), 0]); + + Assert.AreEqual(301 , message[f("repeated_int32" ), 1]); + Assert.AreEqual(302L , message[f("repeated_int64" ), 1]); + Assert.AreEqual(303U , message[f("repeated_uint32" ), 1]); + Assert.AreEqual(304UL, message[f("repeated_uint64" ), 1]); + Assert.AreEqual(305 , message[f("repeated_sint32" ), 1]); + Assert.AreEqual(306L , message[f("repeated_sint64" ), 1]); + Assert.AreEqual(307U , message[f("repeated_fixed32" ), 1]); + Assert.AreEqual(308UL, message[f("repeated_fixed64" ), 1]); + Assert.AreEqual(309 , message[f("repeated_sfixed32"), 1]); + Assert.AreEqual(310L , message[f("repeated_sfixed64"), 1]); + Assert.AreEqual(311F , message[f("repeated_float" ), 1]); + Assert.AreEqual(312D , message[f("repeated_double" ), 1]); + Assert.AreEqual(false, message[f("repeated_bool" ), 1]); + Assert.AreEqual("315", message[f("repeated_string" ), 1]); + Assert.AreEqual(TestUtil.ToBytes("316"), message[f("repeated_bytes"), 1]); + + Assert.AreEqual(317,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]); + Assert.AreEqual(318,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]); + Assert.AreEqual(319,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]); + Assert.AreEqual(320,((IMessage)message[f("repeated_import_message"), 1])[importD]); + + Assert.AreEqual( nestedBaz, message[f("repeated_nested_enum" ),1]); + Assert.AreEqual(foreignBaz, message[f("repeated_foreign_enum"),1]); + Assert.AreEqual( importBaz, message[f("repeated_import_enum" ),1]); + + Assert.AreEqual("324", message[f("repeated_string_piece"), 1]); + Assert.AreEqual("325", message[f("repeated_cord"), 1]); + + // ----------------------------------------------------------------- + + Assert.IsTrue(message.HasField(f("default_int32" ))); + Assert.IsTrue(message.HasField(f("default_int64" ))); + Assert.IsTrue(message.HasField(f("default_uint32" ))); + Assert.IsTrue(message.HasField(f("default_uint64" ))); + Assert.IsTrue(message.HasField(f("default_sint32" ))); + Assert.IsTrue(message.HasField(f("default_sint64" ))); + Assert.IsTrue(message.HasField(f("default_fixed32" ))); + Assert.IsTrue(message.HasField(f("default_fixed64" ))); + Assert.IsTrue(message.HasField(f("default_sfixed32"))); + Assert.IsTrue(message.HasField(f("default_sfixed64"))); + Assert.IsTrue(message.HasField(f("default_float" ))); + Assert.IsTrue(message.HasField(f("default_double" ))); + Assert.IsTrue(message.HasField(f("default_bool" ))); + Assert.IsTrue(message.HasField(f("default_string" ))); + Assert.IsTrue(message.HasField(f("default_bytes" ))); + + Assert.IsTrue(message.HasField(f("default_nested_enum" ))); + Assert.IsTrue(message.HasField(f("default_foreign_enum"))); + Assert.IsTrue(message.HasField(f("default_import_enum" ))); + + Assert.IsTrue(message.HasField(f("default_string_piece"))); + Assert.IsTrue(message.HasField(f("default_cord"))); + + Assert.AreEqual(401 , message[f("default_int32" )]); + Assert.AreEqual(402L , message[f("default_int64" )]); + Assert.AreEqual(403U , message[f("default_uint32" )]); + Assert.AreEqual(404UL, message[f("default_uint64" )]); + Assert.AreEqual(405 , message[f("default_sint32" )]); + Assert.AreEqual(406L , message[f("default_sint64" )]); + Assert.AreEqual(407U , message[f("default_fixed32" )]); + Assert.AreEqual(408UL, message[f("default_fixed64" )]); + Assert.AreEqual(409 , message[f("default_sfixed32")]); + Assert.AreEqual(410L , message[f("default_sfixed64")]); + Assert.AreEqual(411F , message[f("default_float" )]); + Assert.AreEqual(412D , message[f("default_double" )]); + Assert.AreEqual(false, message[f("default_bool" )]); + Assert.AreEqual("415", message[f("default_string" )]); + Assert.AreEqual(TestUtil.ToBytes("416"), message[f("default_bytes")]); + + Assert.AreEqual( nestedFoo, message[f("default_nested_enum" )]); + Assert.AreEqual(foreignFoo, message[f("default_foreign_enum")]); + Assert.AreEqual( importFoo, message[f("default_import_enum" )]); + + Assert.AreEqual("424", message[f("default_string_piece")]); + Assert.AreEqual("425", message[f("default_cord")]); + } + + /// <summary> + /// Assert that all fields of the message are cleared, and that + /// getting the fields returns their default values, using the reflection interface. + /// </summary> + public void AssertClearViaReflection(IMessage message) { + // has_blah() should initially be false for all optional fields. + Assert.IsFalse(message.HasField(f("optional_int32" ))); + Assert.IsFalse(message.HasField(f("optional_int64" ))); + Assert.IsFalse(message.HasField(f("optional_uint32" ))); + Assert.IsFalse(message.HasField(f("optional_uint64" ))); + Assert.IsFalse(message.HasField(f("optional_sint32" ))); + Assert.IsFalse(message.HasField(f("optional_sint64" ))); + Assert.IsFalse(message.HasField(f("optional_fixed32" ))); + Assert.IsFalse(message.HasField(f("optional_fixed64" ))); + Assert.IsFalse(message.HasField(f("optional_sfixed32"))); + Assert.IsFalse(message.HasField(f("optional_sfixed64"))); + Assert.IsFalse(message.HasField(f("optional_float" ))); + Assert.IsFalse(message.HasField(f("optional_double" ))); + Assert.IsFalse(message.HasField(f("optional_bool" ))); + Assert.IsFalse(message.HasField(f("optional_string" ))); + Assert.IsFalse(message.HasField(f("optional_bytes" ))); + + Assert.IsFalse(message.HasField(f("optionalgroup" ))); + Assert.IsFalse(message.HasField(f("optional_nested_message" ))); + Assert.IsFalse(message.HasField(f("optional_foreign_message"))); + Assert.IsFalse(message.HasField(f("optional_import_message" ))); + + Assert.IsFalse(message.HasField(f("optional_nested_enum" ))); + Assert.IsFalse(message.HasField(f("optional_foreign_enum"))); + Assert.IsFalse(message.HasField(f("optional_import_enum" ))); + + Assert.IsFalse(message.HasField(f("optional_string_piece"))); + Assert.IsFalse(message.HasField(f("optional_cord"))); + + // Optional fields without defaults are set to zero or something like it. + Assert.AreEqual(0 , message[f("optional_int32" )]); + Assert.AreEqual(0L , message[f("optional_int64" )]); + Assert.AreEqual(0U , message[f("optional_uint32" )]); + Assert.AreEqual(0UL , message[f("optional_uint64" )]); + Assert.AreEqual(0 , message[f("optional_sint32" )]); + Assert.AreEqual(0L , message[f("optional_sint64" )]); + Assert.AreEqual(0U , message[f("optional_fixed32" )]); + Assert.AreEqual(0UL , message[f("optional_fixed64" )]); + Assert.AreEqual(0 , message[f("optional_sfixed32")]); + Assert.AreEqual(0L , message[f("optional_sfixed64")]); + Assert.AreEqual(0F , message[f("optional_float" )]); + Assert.AreEqual(0D , message[f("optional_double" )]); + Assert.AreEqual(false, message[f("optional_bool" )]); + Assert.AreEqual("" , message[f("optional_string" )]); + Assert.AreEqual(ByteString.Empty, message[f("optional_bytes")]); + + // Embedded messages should also be clear. + Assert.IsFalse(((IMessage)message[f("optionalgroup")]).HasField(groupA)); + Assert.IsFalse(((IMessage)message[f("optional_nested_message")]) + .HasField(nestedB)); + Assert.IsFalse(((IMessage)message[f("optional_foreign_message")]) + .HasField(foreignC)); + Assert.IsFalse(((IMessage)message[f("optional_import_message")]) + .HasField(importD)); + + Assert.AreEqual(0,((IMessage)message[f("optionalgroup")])[groupA]); + Assert.AreEqual(0,((IMessage)message[f("optional_nested_message")])[nestedB]); + Assert.AreEqual(0,((IMessage)message[f("optional_foreign_message")])[foreignC]); + Assert.AreEqual(0,((IMessage)message[f("optional_import_message")])[importD]); + + // Enums without defaults are set to the first value in the enum. + Assert.AreEqual( nestedFoo, message[f("optional_nested_enum" )]); + Assert.AreEqual(foreignFoo, message[f("optional_foreign_enum")]); + Assert.AreEqual( importFoo, message[f("optional_import_enum" )]); + + Assert.AreEqual("", message[f("optional_string_piece")]); + Assert.AreEqual("", message[f("optional_cord")]); + + // Repeated fields are empty. + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int32" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_int64" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint32" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_uint64" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint32" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sint64" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed32" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_fixed64" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_float" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_double" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bool" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_bytes" ))); + + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeatedgroup" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_message" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_message" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_nested_enum" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_foreign_enum" ))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_import_enum" ))); + + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_string_piece"))); + Assert.AreEqual(0, message.GetRepeatedFieldCount(f("repeated_cord"))); + + // has_blah() should also be false for all default fields. + Assert.IsFalse(message.HasField(f("default_int32" ))); + Assert.IsFalse(message.HasField(f("default_int64" ))); + Assert.IsFalse(message.HasField(f("default_uint32" ))); + Assert.IsFalse(message.HasField(f("default_uint64" ))); + Assert.IsFalse(message.HasField(f("default_sint32" ))); + Assert.IsFalse(message.HasField(f("default_sint64" ))); + Assert.IsFalse(message.HasField(f("default_fixed32" ))); + Assert.IsFalse(message.HasField(f("default_fixed64" ))); + Assert.IsFalse(message.HasField(f("default_sfixed32"))); + Assert.IsFalse(message.HasField(f("default_sfixed64"))); + Assert.IsFalse(message.HasField(f("default_float" ))); + Assert.IsFalse(message.HasField(f("default_double" ))); + Assert.IsFalse(message.HasField(f("default_bool" ))); + Assert.IsFalse(message.HasField(f("default_string" ))); + Assert.IsFalse(message.HasField(f("default_bytes" ))); + + Assert.IsFalse(message.HasField(f("default_nested_enum" ))); + Assert.IsFalse(message.HasField(f("default_foreign_enum"))); + Assert.IsFalse(message.HasField(f("default_import_enum" ))); + + Assert.IsFalse(message.HasField(f("default_string_piece" ))); + Assert.IsFalse(message.HasField(f("default_cord" ))); + + // Fields with defaults have their default values (duh). + Assert.AreEqual( 41 , message[f("default_int32" )]); + Assert.AreEqual( 42L , message[f("default_int64" )]); + Assert.AreEqual( 43U , message[f("default_uint32" )]); + Assert.AreEqual( 44UL , message[f("default_uint64" )]); + Assert.AreEqual(-45 , message[f("default_sint32" )]); + Assert.AreEqual( 46L , message[f("default_sint64" )]); + Assert.AreEqual( 47U , message[f("default_fixed32" )]); + Assert.AreEqual( 48UL , message[f("default_fixed64" )]); + Assert.AreEqual( 49 , message[f("default_sfixed32")]); + Assert.AreEqual(-50L , message[f("default_sfixed64")]); + Assert.AreEqual( 51.5F , message[f("default_float" )]); + Assert.AreEqual( 52e3D , message[f("default_double" )]); + Assert.AreEqual(true , message[f("default_bool" )]); + Assert.AreEqual("hello", message[f("default_string" )]); + Assert.AreEqual(TestUtil.ToBytes("world"), message[f("default_bytes")]); + + Assert.AreEqual( nestedBar, message[f("default_nested_enum" )]); + Assert.AreEqual(foreignBar, message[f("default_foreign_enum")]); + Assert.AreEqual( importBar, message[f("default_import_enum" )]); + + Assert.AreEqual("abc", message[f("default_string_piece")]); + Assert.AreEqual("123", message[f("default_cord")]); + } + + // --------------------------------------------------------------- + + internal void AssertRepeatedFieldsModifiedViaReflection(IMessage message) { + // ModifyRepeatedFields only sets the second repeated element of each + // field. In addition to verifying this, we also verify that the first + // element and size were *not* modified. + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_int64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_uint64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sint64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed32" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_fixed64" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed32"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_sfixed64"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_float" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_double" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bool" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_bytes" ))); + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeatedgroup" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_message" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_message"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_message" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_nested_enum" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_foreign_enum" ))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_import_enum" ))); + + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_string_piece"))); + Assert.AreEqual(2, message.GetRepeatedFieldCount(f("repeated_cord"))); + + Assert.AreEqual(201 , message[f("repeated_int32" ), 0]); + Assert.AreEqual(202L , message[f("repeated_int64" ), 0]); + Assert.AreEqual(203U , message[f("repeated_uint32" ), 0]); + Assert.AreEqual(204UL, message[f("repeated_uint64" ), 0]); + Assert.AreEqual(205 , message[f("repeated_sint32" ), 0]); + Assert.AreEqual(206L , message[f("repeated_sint64" ), 0]); + Assert.AreEqual(207U , message[f("repeated_fixed32" ), 0]); + Assert.AreEqual(208UL, message[f("repeated_fixed64" ), 0]); + Assert.AreEqual(209 , message[f("repeated_sfixed32"), 0]); + Assert.AreEqual(210L , message[f("repeated_sfixed64"), 0]); + Assert.AreEqual(211F , message[f("repeated_float" ), 0]); + Assert.AreEqual(212D , message[f("repeated_double" ), 0]); + Assert.AreEqual(true , message[f("repeated_bool" ), 0]); + Assert.AreEqual("215", message[f("repeated_string" ), 0]); + Assert.AreEqual(TestUtil.ToBytes("216"), message[f("repeated_bytes"), 0]); + + Assert.AreEqual(217,((IMessage)message[f("repeatedgroup"), 0])[repeatedGroupA]); + Assert.AreEqual(218,((IMessage)message[f("repeated_nested_message"), 0])[nestedB]); + Assert.AreEqual(219,((IMessage)message[f("repeated_foreign_message"), 0])[foreignC]); + Assert.AreEqual(220,((IMessage)message[f("repeated_import_message"), 0])[importD]); + + Assert.AreEqual( nestedBar, message[f("repeated_nested_enum" ),0]); + Assert.AreEqual(foreignBar, message[f("repeated_foreign_enum"),0]); + Assert.AreEqual( importBar, message[f("repeated_import_enum" ),0]); + + Assert.AreEqual("224", message[f("repeated_string_piece"), 0]); + Assert.AreEqual("225", message[f("repeated_cord"), 0]); + + Assert.AreEqual(501 , message[f("repeated_int32" ), 1]); + Assert.AreEqual(502L , message[f("repeated_int64" ), 1]); + Assert.AreEqual(503U , message[f("repeated_uint32" ), 1]); + Assert.AreEqual(504UL, message[f("repeated_uint64" ), 1]); + Assert.AreEqual(505 , message[f("repeated_sint32" ), 1]); + Assert.AreEqual(506L , message[f("repeated_sint64" ), 1]); + Assert.AreEqual(507U , message[f("repeated_fixed32" ), 1]); + Assert.AreEqual(508UL, message[f("repeated_fixed64" ), 1]); + Assert.AreEqual(509 , message[f("repeated_sfixed32"), 1]); + Assert.AreEqual(510L , message[f("repeated_sfixed64"), 1]); + Assert.AreEqual(511F , message[f("repeated_float" ), 1]); + Assert.AreEqual(512D , message[f("repeated_double" ), 1]); + Assert.AreEqual(true , message[f("repeated_bool" ), 1]); + Assert.AreEqual("515", message[f("repeated_string" ), 1]); + Assert.AreEqual(TestUtil.ToBytes("516"), message[f("repeated_bytes"), 1]); + + Assert.AreEqual(517,((IMessage)message[f("repeatedgroup"), 1])[repeatedGroupA]); + Assert.AreEqual(518,((IMessage)message[f("repeated_nested_message"), 1])[nestedB]); + Assert.AreEqual(519,((IMessage)message[f("repeated_foreign_message"), 1])[foreignC]); + Assert.AreEqual(520,((IMessage)message[f("repeated_import_message"), 1])[importD]); + + Assert.AreEqual( nestedFoo, message[f("repeated_nested_enum" ),1]); + Assert.AreEqual(foreignFoo, message[f("repeated_foreign_enum"),1]); + Assert.AreEqual( importFoo, message[f("repeated_import_enum" ),1]); + + Assert.AreEqual("524", message[f("repeated_string_piece"), 1]); + Assert.AreEqual("525", message[f("repeated_cord"), 1]); + } + } +} diff --git a/src/ProtocolBuffers.Test/ServiceTest.cs b/src/ProtocolBuffers.Test/ServiceTest.cs new file mode 100644 index 00000000..34f83bda --- /dev/null +++ b/src/ProtocolBuffers.Test/ServiceTest.cs @@ -0,0 +1,178 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; +using Rhino.Mocks; +using Rhino.Mocks.Constraints; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// Tests for generated service classes. + /// TODO(jonskeet): Convert the mocking tests using Rhino.Mocks. + /// </summary> + [TestFixture] + public class ServiceTest { + + delegate void Action<T1, T2>(T1 t1, T2 t2); + + private static readonly MethodDescriptor FooDescriptor = TestService.Descriptor.Methods[0]; + private static readonly MethodDescriptor BarDescriptor = TestService.Descriptor.Methods[1]; + + [Test] + public void GetRequestPrototype() { + TestService service = new TestServiceImpl(); + + Assert.AreSame(service.GetRequestPrototype(FooDescriptor), FooRequest.DefaultInstance); + Assert.AreSame(service.GetRequestPrototype(BarDescriptor), BarRequest.DefaultInstance); + } + + [Test] + public void GetResponsePrototype() { + TestService service = new TestServiceImpl(); + + Assert.AreSame(service.GetResponsePrototype(FooDescriptor), FooResponse.DefaultInstance); + Assert.AreSame(service.GetResponsePrototype(BarDescriptor), BarResponse.DefaultInstance); + } + + [Test] + public void CallMethodFoo() { + MockRepository mocks = new MockRepository(); + FooRequest fooRequest = FooRequest.CreateBuilder().Build(); + FooResponse fooResponse = FooResponse.CreateBuilder().Build(); + IRpcController controller = mocks.StrictMock<IRpcController>(); + + bool fooCalled = false; + + TestService service = new TestServiceImpl((request, responseAction) => { + Assert.AreSame(fooRequest, request); + fooCalled = true; + responseAction(fooResponse); + }, null, controller); + + bool doneHandlerCalled = false; + Action<IMessage> doneHandler = (response => { + Assert.AreSame(fooResponse, response); + doneHandlerCalled = true; + }); + + using (mocks.Record()) { + // No mock interactions to record + } + + service.CallMethod(FooDescriptor, controller, fooRequest, doneHandler); + + Assert.IsTrue(doneHandlerCalled); + Assert.IsTrue(fooCalled); + mocks.VerifyAll(); + } + + delegate void CallFooDelegate(MethodDescriptor descriptor, IRpcController controller, + IMessage request, IMessage response, Action<IMessage> doneHandler); + + /// <summary> + /// Tests the generated stub handling of Foo. By this stage we're reasonably confident + /// that the choice between Foo and Bar is arbitrary, hence the lack of a corresponding Bar + /// test. + /// </summary> + [Test] + public void GeneratedStubFooCall() { + FooRequest fooRequest = FooRequest.CreateBuilder().Build(); + MockRepository mocks = new MockRepository(); + IRpcChannel mockChannel = mocks.StrictMock<IRpcChannel>(); + IRpcController mockController = mocks.StrictMock<IRpcController>(); + TestService service = TestService.CreateStub(mockChannel); + Action<FooResponse> doneHandler = mocks.StrictMock<Action<FooResponse>>(); + + using (mocks.Record()) { + + // Nasty way of mocking out "the channel calls the done handler". + Expect.Call(() => mockChannel.CallMethod(null, null, null, null, null)) + .IgnoreArguments() + .Constraints(Is.Same(FooDescriptor), Is.Same(mockController), Is.Same(fooRequest), + Is.Same(FooResponse.DefaultInstance), Is.Anything()) + .Do((CallFooDelegate) ((p1, p2, p3, response, done) => done(response))); + doneHandler.Invoke(FooResponse.DefaultInstance); + } + + service.Foo(mockController, fooRequest, doneHandler); + + mocks.VerifyAll(); + } + + [Test] + public void CallMethodBar() { + MockRepository mocks = new MockRepository(); + BarRequest barRequest = BarRequest.CreateBuilder().Build(); + BarResponse barResponse = BarResponse.CreateBuilder().Build(); + IRpcController controller = mocks.StrictMock<IRpcController>(); + + bool barCalled = false; + + TestService service = new TestServiceImpl(null, (request, responseAction) => { + Assert.AreSame(barRequest, request); + barCalled = true; + responseAction(barResponse); + }, controller); + + bool doneHandlerCalled = false; + Action<IMessage> doneHandler = (response => { + Assert.AreSame(barResponse, response); + doneHandlerCalled = true; + }); + + using (mocks.Record()) { + // No mock interactions to record + } + + service.CallMethod(BarDescriptor, controller, barRequest, doneHandler); + + Assert.IsTrue(doneHandlerCalled); + Assert.IsTrue(barCalled); + mocks.VerifyAll(); + } + + + class TestServiceImpl : TestService { + private readonly Action<FooRequest, Action<FooResponse>> fooHandler; + private readonly Action<BarRequest, Action<BarResponse>> barHandler; + private readonly IRpcController expectedController; + + internal TestServiceImpl() { + } + + internal TestServiceImpl(Action<FooRequest, Action<FooResponse>> fooHandler, + Action<BarRequest, Action<BarResponse>> barHandler, + IRpcController expectedController) { + this.fooHandler = fooHandler; + this.barHandler = barHandler; + this.expectedController = expectedController; + } + + public override void Foo(IRpcController controller, FooRequest request, Action<FooResponse> done) { + Assert.AreSame(expectedController, controller); + fooHandler(request, done); + } + + public override void Bar(IRpcController controller, BarRequest request, Action<BarResponse> done) { + Assert.AreSame(expectedController, controller); + barHandler(request, done); + } + } + } +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs new file mode 100644 index 00000000..8a1def53 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs @@ -0,0 +1,2251 @@ +// 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.TestProtos { + + public static partial class UnitTestCustomOptionsProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "Ci1nb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfY3VzdG9tX29wdGlvbnMucHJv" + + "dG8SEXByb3RvYnVmX3VuaXR0ZXN0GiRnb29nbGUvcHJvdG9idWYvY3NoYXJw" + + "X29wdGlvbnMucHJvdG8aIGdvb2dsZS9wcm90b2J1Zi9kZXNjcmlwdG9yLnBy" + + "b3RvIpoBChxUZXN0TWVzc2FnZVdpdGhDdXN0b21PcHRpb25zEioKBmZpZWxk" + + "MRgBIAEoCUIaCAHB4MMdLeF1CgIAAADB4MMdLeF1CgIAAAAiPAoGQW5FbnVt" + + "Eg8KC0FORU5VTV9WQUwxEAESDwoLQU5FTlVNX1ZBTDIQAhoQxfbJHev8///F" + + "9skd6/z//zoQCADg6cIdyP//////////ASIYChZDdXN0b21PcHRpb25Gb29S" + + "ZXF1ZXN0IhkKF0N1c3RvbU9wdGlvbkZvb1Jlc3BvbnNlIm0KGkR1bW15TWVz" + + "c2FnZUNvbnRhaW5pbmdFbnVtIk8KDFRlc3RFbnVtVHlwZRIaChZURVNUX09Q" + + "VElPTl9FTlVNX1RZUEUxEBYSIwoWVEVTVF9PUFRJT05fRU5VTV9UWVBFMhDp" + + "//////////8BIiEKH0R1bW15TWVzc2FnZUludmFsaWRBc09wdGlvblR5cGUi" + + "swEKHEN1c3RvbU9wdGlvbk1pbkludGVnZXJWYWx1ZXM6kgGZ1qgdAAAAAAAA" + + "AICZ1qgdAAAAAAAAAICtja8dAAAAgK2Nrx0AAACAke6vHQAAAAAAAAAAke6v" + + "HQAAAAAAAAAAnfWvHQAAAACd9a8dAAAAAPiXsB3///////////8BgMSwHf//" + + "//8P+PWwHQCAk7IdALC8sh2AgICAgICAgIAB6MayHYCAgID4/////wHQ3rId" + + "ACK6AQocQ3VzdG9tT3B0aW9uTWF4SW50ZWdlclZhbHVlczqZAZnWqB3/////" + + "////f5nWqB3/////////f62Nrx3///9/rY2vHf///3+R7q8d//////////+R" + + "7q8d//////////+d9a8d/////531rx3/////+JewHf7//////////wGAxLAd" + + "/v///w/49bAd////////////AYCTsh3/////D7C8sh3//////////3/oxrId" + + "/////wfQ3rIdASKCAQoXQ3VzdG9tT3B0aW9uT3RoZXJWYWx1ZXM6Z4jZoh3p" + + "//////////8BstmiHQtIZWxsbwBXb3JsZKrcoh0OSGVsbG8sICJXb3JsZCLp" + + "3KId+1mMQsrA8z/p3KId+1mMQsrA8z/136Md54dFQfXfox3nh0VB6MayHZz/" + + "/////////wEiSAocU2V0dGluZ1JlYWxzRnJvbVBvc2l0aXZlSW50czoo6dyi" + + "HQAAAAAAQGNA6dyiHQAAAAAAQGNA9d+jHQAAQEH136MdAABAQSJIChxTZXR0" + + "aW5nUmVhbHNGcm9tTmVnYXRpdmVJbnRzOijp3KIdAAAAAABAY8Dp3KIdAAAA" + + "AABAY8D136MdAABAwfXfox0AAEDBIisKEkNvbXBsZXhPcHRpb25UeXBlMRIL" + + "CgNmb28YASABKAUqCAhkEICAgIACIsECChJDb21wbGV4T3B0aW9uVHlwZTIS" + + "MgoDYmFyGAEgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdGlv" + + "blR5cGUxEgsKA2JhehgCIAEoBRJGCgRmcmVkGAMgASgLMjgucHJvdG9idWZf" + + "dW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUyLkNvbXBsZXhPcHRpb25UeXBl" + + "NBqXAQoSQ29tcGxleE9wdGlvblR5cGU0Eg0KBXdhbGRvGAEgASgFMnIKDGNv" + + "bXBsZXhfb3B0NBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxiK" + + "9dEDIAEoCzI4LnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBl" + + "Mi5Db21wbGV4T3B0aW9uVHlwZTQqCAhkEICAgIACIpwBChJDb21wbGV4T3B0" + + "aW9uVHlwZTMSCwoDcXV4GAEgASgFElQKEmNvbXBsZXhvcHRpb250eXBlNRgC" + + "IAEoCjI4LnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMy5D" + + "b21wbGV4T3B0aW9uVHlwZTUaIwoSQ29tcGxleE9wdGlvblR5cGU1Eg0KBXBs" + + "dWdoGAMgASgFIh8KC0NvbXBsZXhPcHQ2EhAKBXh5enp5GN+/zwMgASgFItAB" + + "ChVWYXJpb3VzQ29tcGxleE9wdGlvbnM6tgHj3Pwc+P37HBjk3Pwc0qiPHQMI" + + "sw/63pAdAggJ+t6QHQQTGBYUqv2QHQMQ2weq/ZAdBvjmlx2OBar9kB0FCgMI" + + "5wWq/ZAdCAoG2IWeHc8Pqv2QHQoKCJL1nR0DCNgPqv2QHQjCrJcdAwjlBar9" + + "kB0LwqyXHQbYhZ4dzg+q/ZAdDcKslx0IkvWdHQMIyRCq/ZAdBRoDCMECouKV" + + "HQIIKqLilR0G2IWeHcQCouKVHQiS9Z0dAwjsBio2CgpNZXRob2RPcHQxEhMK" + + "D01FVEhPRE9QVDFfVkFMMRABEhMKD01FVEhPRE9QVDFfVkFMMhACMo4BChxU" + + "ZXN0U2VydmljZVdpdGhDdXN0b21PcHRpb25zEmMKA0ZvbxIpLnByb3RvYnVm" + + "X3VuaXR0ZXN0LkN1c3RvbU9wdGlvbkZvb1JlcXVlc3QaKi5wcm90b2J1Zl91" + + "bml0dGVzdC5DdXN0b21PcHRpb25Gb29SZXNwb25zZSIF4PqMHgIaCZCyix7T" + + "24DLSToyCglmaWxlX29wdDESHC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlv" + + "bnMYjp3YAyABKAQ6OAoMbWVzc2FnZV9vcHQxEh8uZ29vZ2xlLnByb3RvYnVm" + + "Lk1lc3NhZ2VPcHRpb25zGJyt2AMgASgFOjQKCmZpZWxkX29wdDESHS5nb29n" + + "bGUucHJvdG9idWYuRmllbGRPcHRpb25zGIi82AMgASgGOjgKCmZpZWxkX29w" + + "dDISHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25zGLmh2QMgASgFOgI0" + + "MjoyCgllbnVtX29wdDESHC5nb29nbGUucHJvdG9idWYuRW51bU9wdGlvbnMY" + + "6J7ZAyABKA86OAoMc2VydmljZV9vcHQxEh8uZ29vZ2xlLnByb3RvYnVmLlNl" + + "cnZpY2VPcHRpb25zGKK24QMgASgSOlUKC21ldGhvZF9vcHQxEh4uZ29vZ2xl" + + "LnByb3RvYnVmLk1ldGhvZE9wdGlvbnMYrM/hAyABKA4yHS5wcm90b2J1Zl91" + + "bml0dGVzdC5NZXRob2RPcHQxOjQKCGJvb2xfb3B0Eh8uZ29vZ2xlLnByb3Rv" + + "YnVmLk1lc3NhZ2VPcHRpb25zGOqr1gMgASgIOjUKCWludDMyX29wdBIfLmdv" + + "b2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjtqNYDIAEoBTo1CglpbnQ2" + + "NF9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYxqfWAyAB" + + "KAM6NgoKdWludDMyX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0" + + "aW9ucxiwotYDIAEoDTo2Cgp1aW50NjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVm" + + "Lk1lc3NhZ2VPcHRpb25zGN+O1gMgASgEOjYKCnNpbnQzMl9vcHQSHy5nb29n" + + "bGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYwIjWAyABKBE6NgoKc2ludDY0" + + "X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxj/gtYDIAEo" + + "Ejo3CgtmaXhlZDMyX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0" + + "aW9ucxjT/tUDIAEoBzo3CgtmaXhlZDY0X29wdBIfLmdvb2dsZS5wcm90b2J1" + + "Zi5NZXNzYWdlT3B0aW9ucxji/dUDIAEoBjo4CgxzZml4ZWQzMl9vcHQSHy5n" + + "b29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY1fHVAyABKA86OAoMc2Zp" + + "eGVkNjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGOOK" + + "1QMgASgQOjUKCWZsb2F0X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdl" + + "T3B0aW9ucxj+u9QDIAEoAjo2Cgpkb3VibGVfb3B0Eh8uZ29vZ2xlLnByb3Rv" + + "YnVmLk1lc3NhZ2VPcHRpb25zGM2r1AMgASgBOjYKCnN0cmluZ19vcHQSHy5n" + + "b29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYxavUAyABKAk6NQoJYnl0" + + "ZXNfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGJar1AMg" + + "ASgMOnAKCGVudW1fb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRp" + + "b25zGJGr1AMgASgOMjoucHJvdG9idWZfdW5pdHRlc3QuRHVtbXlNZXNzYWdl" + + "Q29udGFpbmluZ0VudW0uVGVzdEVudW1UeXBlOnAKEG1lc3NhZ2VfdHlwZV9v" + + "cHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYr/LTAyABKAsy" + + "Mi5wcm90b2J1Zl91bml0dGVzdC5EdW1teU1lc3NhZ2VJbnZhbGlkQXNPcHRp" + + "b25UeXBlOjYKBHF1dXgSJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0" + + "aW9uVHlwZTEY2+DTAyABKAU6XgoFY29yZ2USJS5wcm90b2J1Zl91bml0dGVz" + + "dC5Db21wbGV4T3B0aW9uVHlwZTEY0t7TAyABKAsyJS5wcm90b2J1Zl91bml0" + + "dGVzdC5Db21wbGV4T3B0aW9uVHlwZTM6OAoGZ3JhdWx0EiUucHJvdG9idWZf" + + "dW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUyGO/80gMgASgFOl8KBmdhcnBs" + + "eRIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMhjI9dID" + + "IAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMTpf" + + "Cgxjb21wbGV4X29wdDESHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlv" + + "bnMYpNzSAyABKAsyJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9u" + + "VHlwZTE6XwoMY29tcGxleF9vcHQyEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3Nh" + + "Z2VPcHRpb25zGNWP0gMgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxl" + + "eE9wdGlvblR5cGUyOl8KDGNvbXBsZXhfb3B0MxIfLmdvb2dsZS5wcm90b2J1" + + "Zi5NZXNzYWdlT3B0aW9ucxjvi9IDIAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0" + + "LkNvbXBsZXhPcHRpb25UeXBlMzpXCgtjb21wbGV4b3B0NhIfLmdvb2dsZS5w" + + "cm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjMy88DIAEoCjIeLnByb3RvYnVmX3Vu" + + "aXR0ZXN0LkNvbXBsZXhPcHQ2QlCC4gkhR29vZ2xlLlByb3RvY29sQnVmZmVy" + + "cy5UZXN0UHJvdG9ziuIJHlVuaXRUZXN0Q3VzdG9tT3B0aW9uc1Byb3RvRmls" + + "ZfDowR3qrcDlJA=="), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + }); + #endregion + + #region Extensions + public static readonly pb::GeneratedExtensionBase<ulong> FileOpt1 = + pb::GeneratedSingleExtension<ulong>.CreateInstance(Descriptor.Extensions[0]); + public static readonly pb::GeneratedExtensionBase<int> MessageOpt1 = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[1]); + public static readonly pb::GeneratedExtensionBase<ulong> FieldOpt1 = + pb::GeneratedSingleExtension<ulong>.CreateInstance(Descriptor.Extensions[2]); + public static readonly pb::GeneratedExtensionBase<int> FieldOpt2 = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[3]); + public static readonly pb::GeneratedExtensionBase<int> EnumOpt1 = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[4]); + public static readonly pb::GeneratedExtensionBase<long> ServiceOpt1 = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[5]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.MethodOpt1> MethodOpt1 = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.MethodOpt1>.CreateInstance(Descriptor.Extensions[6]); + public static readonly pb::GeneratedExtensionBase<bool> BoolOpt = + pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[7]); + public static readonly pb::GeneratedExtensionBase<int> Int32Opt = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[8]); + public static readonly pb::GeneratedExtensionBase<long> Int64Opt = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[9]); + public static readonly pb::GeneratedExtensionBase<uint> Uint32Opt = + pb::GeneratedSingleExtension<uint>.CreateInstance(Descriptor.Extensions[10]); + public static readonly pb::GeneratedExtensionBase<ulong> Uint64Opt = + pb::GeneratedSingleExtension<ulong>.CreateInstance(Descriptor.Extensions[11]); + public static readonly pb::GeneratedExtensionBase<int> Sint32Opt = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[12]); + public static readonly pb::GeneratedExtensionBase<long> Sint64Opt = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[13]); + public static readonly pb::GeneratedExtensionBase<uint> Fixed32Opt = + pb::GeneratedSingleExtension<uint>.CreateInstance(Descriptor.Extensions[14]); + public static readonly pb::GeneratedExtensionBase<ulong> Fixed64Opt = + pb::GeneratedSingleExtension<ulong>.CreateInstance(Descriptor.Extensions[15]); + public static readonly pb::GeneratedExtensionBase<int> Sfixed32Opt = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[16]); + public static readonly pb::GeneratedExtensionBase<long> Sfixed64Opt = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[17]); + public static readonly pb::GeneratedExtensionBase<float> FloatOpt = + pb::GeneratedSingleExtension<float>.CreateInstance(Descriptor.Extensions[18]); + public static readonly pb::GeneratedExtensionBase<double> DoubleOpt = + pb::GeneratedSingleExtension<double>.CreateInstance(Descriptor.Extensions[19]); + public static readonly pb::GeneratedExtensionBase<string> StringOpt = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[20]); + public static readonly pb::GeneratedExtensionBase<pb::ByteString> BytesOpt = + pb::GeneratedSingleExtension<pb::ByteString>.CreateInstance(Descriptor.Extensions[21]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.DummyMessageContainingEnum.Types.TestEnumType> EnumOpt = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.DummyMessageContainingEnum.Types.TestEnumType>.CreateInstance(Descriptor.Extensions[22]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.DummyMessageInvalidAsOptionType> MessageTypeOpt = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.DummyMessageInvalidAsOptionType>.CreateInstance(Descriptor.Extensions[23]); + public static readonly pb::GeneratedExtensionBase<int> Quux = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[24]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3> Corge = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3>.CreateInstance(Descriptor.Extensions[25]); + public static readonly pb::GeneratedExtensionBase<int> Grault = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[26]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1> Garply = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1>.CreateInstance(Descriptor.Extensions[27]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1> ComplexOpt1 = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1>.CreateInstance(Descriptor.Extensions[28]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2> ComplexOpt2 = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2>.CreateInstance(Descriptor.Extensions[29]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3> ComplexOpt3 = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3>.CreateInstance(Descriptor.Extensions[30]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ComplexOpt6> ComplexOpt6 = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOpt6>.CreateInstance(Descriptor.Extensions[31]); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageWithCustomOptions__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageWithCustomOptions, global::Google.ProtocolBuffers.TestProtos.TestMessageWithCustomOptions.Builder> internal__static_protobuf_unittest_TestMessageWithCustomOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageWithCustomOptions, global::Google.ProtocolBuffers.TestProtos.TestMessageWithCustomOptions.Builder>(internal__static_protobuf_unittest_TestMessageWithCustomOptions__Descriptor, + new string[] { "Field1", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionFooRequest__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest, global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest.Builder> internal__static_protobuf_unittest_CustomOptionFooRequest__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest, global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest.Builder>(internal__static_protobuf_unittest_CustomOptionFooRequest__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionFooResponse__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse, global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse.Builder> internal__static_protobuf_unittest_CustomOptionFooResponse__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse, global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse.Builder>(internal__static_protobuf_unittest_CustomOptionFooResponse__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_DummyMessageContainingEnum__Descriptor + = Descriptor.MessageTypes[3]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.DummyMessageContainingEnum, global::Google.ProtocolBuffers.TestProtos.DummyMessageContainingEnum.Builder> internal__static_protobuf_unittest_DummyMessageContainingEnum__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.DummyMessageContainingEnum, global::Google.ProtocolBuffers.TestProtos.DummyMessageContainingEnum.Builder>(internal__static_protobuf_unittest_DummyMessageContainingEnum__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__Descriptor + = Descriptor.MessageTypes[4]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.DummyMessageInvalidAsOptionType, global::Google.ProtocolBuffers.TestProtos.DummyMessageInvalidAsOptionType.Builder> internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.DummyMessageInvalidAsOptionType, global::Google.ProtocolBuffers.TestProtos.DummyMessageInvalidAsOptionType.Builder>(internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionMinIntegerValues__Descriptor + = Descriptor.MessageTypes[5]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionMinIntegerValues, global::Google.ProtocolBuffers.TestProtos.CustomOptionMinIntegerValues.Builder> internal__static_protobuf_unittest_CustomOptionMinIntegerValues__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionMinIntegerValues, global::Google.ProtocolBuffers.TestProtos.CustomOptionMinIntegerValues.Builder>(internal__static_protobuf_unittest_CustomOptionMinIntegerValues__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__Descriptor + = Descriptor.MessageTypes[6]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionMaxIntegerValues, global::Google.ProtocolBuffers.TestProtos.CustomOptionMaxIntegerValues.Builder> internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionMaxIntegerValues, global::Google.ProtocolBuffers.TestProtos.CustomOptionMaxIntegerValues.Builder>(internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_CustomOptionOtherValues__Descriptor + = Descriptor.MessageTypes[7]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionOtherValues, global::Google.ProtocolBuffers.TestProtos.CustomOptionOtherValues.Builder> internal__static_protobuf_unittest_CustomOptionOtherValues__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.CustomOptionOtherValues, global::Google.ProtocolBuffers.TestProtos.CustomOptionOtherValues.Builder>(internal__static_protobuf_unittest_CustomOptionOtherValues__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_SettingRealsFromPositiveInts__Descriptor + = Descriptor.MessageTypes[8]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SettingRealsFromPositiveInts, global::Google.ProtocolBuffers.TestProtos.SettingRealsFromPositiveInts.Builder> internal__static_protobuf_unittest_SettingRealsFromPositiveInts__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SettingRealsFromPositiveInts, global::Google.ProtocolBuffers.TestProtos.SettingRealsFromPositiveInts.Builder>(internal__static_protobuf_unittest_SettingRealsFromPositiveInts__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_SettingRealsFromNegativeInts__Descriptor + = Descriptor.MessageTypes[9]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SettingRealsFromNegativeInts, global::Google.ProtocolBuffers.TestProtos.SettingRealsFromNegativeInts.Builder> internal__static_protobuf_unittest_SettingRealsFromNegativeInts__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SettingRealsFromNegativeInts, global::Google.ProtocolBuffers.TestProtos.SettingRealsFromNegativeInts.Builder>(internal__static_protobuf_unittest_SettingRealsFromNegativeInts__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType1__Descriptor + = Descriptor.MessageTypes[10]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.Builder> internal__static_protobuf_unittest_ComplexOptionType1__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.Builder>(internal__static_protobuf_unittest_ComplexOptionType1__Descriptor, + new string[] { "Foo", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType2__Descriptor + = Descriptor.MessageTypes[11]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Builder> internal__static_protobuf_unittest_ComplexOptionType2__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Builder>(internal__static_protobuf_unittest_ComplexOptionType2__Descriptor, + new string[] { "Bar", "Baz", "Fred", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__Descriptor + = internal__static_protobuf_unittest_ComplexOptionType2__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.Builder> internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.Builder>(internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__Descriptor, + new string[] { "Waldo", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType3__Descriptor + = Descriptor.MessageTypes[12]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Builder> internal__static_protobuf_unittest_ComplexOptionType3__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Builder>(internal__static_protobuf_unittest_ComplexOptionType3__Descriptor, + new string[] { "Qux", "ComplexOptionType5", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__Descriptor + = internal__static_protobuf_unittest_ComplexOptionType3__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.Builder> internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5, global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.Builder>(internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__Descriptor, + new string[] { "Plugh", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ComplexOpt6__Descriptor + = Descriptor.MessageTypes[13]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOpt6, global::Google.ProtocolBuffers.TestProtos.ComplexOpt6.Builder> internal__static_protobuf_unittest_ComplexOpt6__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOpt6, global::Google.ProtocolBuffers.TestProtos.ComplexOpt6.Builder>(internal__static_protobuf_unittest_ComplexOpt6__Descriptor, + new string[] { "Xyzzy", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_VariousComplexOptions__Descriptor + = Descriptor.MessageTypes[14]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.VariousComplexOptions, global::Google.ProtocolBuffers.TestProtos.VariousComplexOptions.Builder> internal__static_protobuf_unittest_VariousComplexOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.VariousComplexOptions, global::Google.ProtocolBuffers.TestProtos.VariousComplexOptions.Builder>(internal__static_protobuf_unittest_VariousComplexOptions__Descriptor, + new string[] { }); + #endregion + } + #region Enums + public enum MethodOpt1 { + METHODOPT1_VAL1 = 1, + METHODOPT1_VAL2 = 2, + } + + #endregion + + #region Messages + public sealed partial class TestMessageWithCustomOptions : pb::GeneratedMessage<TestMessageWithCustomOptions, TestMessageWithCustomOptions.Builder> { + private static readonly TestMessageWithCustomOptions defaultInstance = new Builder().BuildPartial(); + public static TestMessageWithCustomOptions DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageWithCustomOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageWithCustomOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_TestMessageWithCustomOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestMessageWithCustomOptions, TestMessageWithCustomOptions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_TestMessageWithCustomOptions__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum AnEnum { + ANENUM_VAL1 = 1, + ANENUM_VAL2 = 2, + } + + } + #endregion + + private bool hasField1; + private string field1_ = ""; + public bool HasField1 { + get { return hasField1; } + } + public string Field1 { + get { return field1_; } + } + + public static TestMessageWithCustomOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageWithCustomOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageWithCustomOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestMessageWithCustomOptions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageWithCustomOptions result = new TestMessageWithCustomOptions(); + + protected override TestMessageWithCustomOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageWithCustomOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageWithCustomOptions.Descriptor; } + } + + public override TestMessageWithCustomOptions DefaultInstanceForType { + get { return TestMessageWithCustomOptions.DefaultInstance; } + } + + public override TestMessageWithCustomOptions BuildPartial() { + TestMessageWithCustomOptions returnMe = result; + result = null; + return returnMe; + } + + + public bool HasField1 { + get { return result.HasField1; } + } + public string Field1 { + get { return result.Field1; } + set { SetField1(value); } + } + public Builder SetField1(string value) { + result.hasField1 = true; + result.field1_ = value; + return this; + } + public Builder ClearField1() { + result.hasField1 = false; + result.field1_ = ""; + return this; + } + } + } + + public sealed partial class CustomOptionFooRequest : pb::GeneratedMessage<CustomOptionFooRequest, CustomOptionFooRequest.Builder> { + private static readonly CustomOptionFooRequest defaultInstance = new Builder().BuildPartial(); + public static CustomOptionFooRequest DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionFooRequest DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionFooRequest ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionFooRequest__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<CustomOptionFooRequest, CustomOptionFooRequest.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionFooRequest__FieldAccessorTable; } + } + + public static CustomOptionFooRequest ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionFooRequest ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionFooRequest prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<CustomOptionFooRequest, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionFooRequest result = new CustomOptionFooRequest(); + + protected override CustomOptionFooRequest MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionFooRequest(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionFooRequest.Descriptor; } + } + + public override CustomOptionFooRequest DefaultInstanceForType { + get { return CustomOptionFooRequest.DefaultInstance; } + } + + public override CustomOptionFooRequest BuildPartial() { + CustomOptionFooRequest returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class CustomOptionFooResponse : pb::GeneratedMessage<CustomOptionFooResponse, CustomOptionFooResponse.Builder> { + private static readonly CustomOptionFooResponse defaultInstance = new Builder().BuildPartial(); + public static CustomOptionFooResponse DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionFooResponse DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionFooResponse ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionFooResponse__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<CustomOptionFooResponse, CustomOptionFooResponse.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionFooResponse__FieldAccessorTable; } + } + + public static CustomOptionFooResponse ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionFooResponse ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionFooResponse prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<CustomOptionFooResponse, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionFooResponse result = new CustomOptionFooResponse(); + + protected override CustomOptionFooResponse MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionFooResponse(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionFooResponse.Descriptor; } + } + + public override CustomOptionFooResponse DefaultInstanceForType { + get { return CustomOptionFooResponse.DefaultInstance; } + } + + public override CustomOptionFooResponse BuildPartial() { + CustomOptionFooResponse returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class DummyMessageContainingEnum : pb::GeneratedMessage<DummyMessageContainingEnum, DummyMessageContainingEnum.Builder> { + private static readonly DummyMessageContainingEnum defaultInstance = new Builder().BuildPartial(); + public static DummyMessageContainingEnum DefaultInstance { + get { return defaultInstance; } + } + + public override DummyMessageContainingEnum DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override DummyMessageContainingEnum ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_DummyMessageContainingEnum__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<DummyMessageContainingEnum, DummyMessageContainingEnum.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_DummyMessageContainingEnum__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum TestEnumType { + TEST_OPTION_ENUM_TYPE1 = 22, + TEST_OPTION_ENUM_TYPE2 = -23, + } + + } + #endregion + + public static DummyMessageContainingEnum ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DummyMessageContainingEnum ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(DummyMessageContainingEnum prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<DummyMessageContainingEnum, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + DummyMessageContainingEnum result = new DummyMessageContainingEnum(); + + protected override DummyMessageContainingEnum MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new DummyMessageContainingEnum(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return DummyMessageContainingEnum.Descriptor; } + } + + public override DummyMessageContainingEnum DefaultInstanceForType { + get { return DummyMessageContainingEnum.DefaultInstance; } + } + + public override DummyMessageContainingEnum BuildPartial() { + DummyMessageContainingEnum returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class DummyMessageInvalidAsOptionType : pb::GeneratedMessage<DummyMessageInvalidAsOptionType, DummyMessageInvalidAsOptionType.Builder> { + private static readonly DummyMessageInvalidAsOptionType defaultInstance = new Builder().BuildPartial(); + public static DummyMessageInvalidAsOptionType DefaultInstance { + get { return defaultInstance; } + } + + public override DummyMessageInvalidAsOptionType DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override DummyMessageInvalidAsOptionType ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<DummyMessageInvalidAsOptionType, DummyMessageInvalidAsOptionType.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_DummyMessageInvalidAsOptionType__FieldAccessorTable; } + } + + public static DummyMessageInvalidAsOptionType ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DummyMessageInvalidAsOptionType ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(DummyMessageInvalidAsOptionType prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<DummyMessageInvalidAsOptionType, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + DummyMessageInvalidAsOptionType result = new DummyMessageInvalidAsOptionType(); + + protected override DummyMessageInvalidAsOptionType MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new DummyMessageInvalidAsOptionType(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return DummyMessageInvalidAsOptionType.Descriptor; } + } + + public override DummyMessageInvalidAsOptionType DefaultInstanceForType { + get { return DummyMessageInvalidAsOptionType.DefaultInstance; } + } + + public override DummyMessageInvalidAsOptionType BuildPartial() { + DummyMessageInvalidAsOptionType returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class CustomOptionMinIntegerValues : pb::GeneratedMessage<CustomOptionMinIntegerValues, CustomOptionMinIntegerValues.Builder> { + private static readonly CustomOptionMinIntegerValues defaultInstance = new Builder().BuildPartial(); + public static CustomOptionMinIntegerValues DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionMinIntegerValues DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionMinIntegerValues ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionMinIntegerValues__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<CustomOptionMinIntegerValues, CustomOptionMinIntegerValues.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionMinIntegerValues__FieldAccessorTable; } + } + + public static CustomOptionMinIntegerValues ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionMinIntegerValues ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionMinIntegerValues prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<CustomOptionMinIntegerValues, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionMinIntegerValues result = new CustomOptionMinIntegerValues(); + + protected override CustomOptionMinIntegerValues MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionMinIntegerValues(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionMinIntegerValues.Descriptor; } + } + + public override CustomOptionMinIntegerValues DefaultInstanceForType { + get { return CustomOptionMinIntegerValues.DefaultInstance; } + } + + public override CustomOptionMinIntegerValues BuildPartial() { + CustomOptionMinIntegerValues returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class CustomOptionMaxIntegerValues : pb::GeneratedMessage<CustomOptionMaxIntegerValues, CustomOptionMaxIntegerValues.Builder> { + private static readonly CustomOptionMaxIntegerValues defaultInstance = new Builder().BuildPartial(); + public static CustomOptionMaxIntegerValues DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionMaxIntegerValues DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionMaxIntegerValues ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<CustomOptionMaxIntegerValues, CustomOptionMaxIntegerValues.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionMaxIntegerValues__FieldAccessorTable; } + } + + public static CustomOptionMaxIntegerValues ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionMaxIntegerValues ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionMaxIntegerValues prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<CustomOptionMaxIntegerValues, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionMaxIntegerValues result = new CustomOptionMaxIntegerValues(); + + protected override CustomOptionMaxIntegerValues MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionMaxIntegerValues(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionMaxIntegerValues.Descriptor; } + } + + public override CustomOptionMaxIntegerValues DefaultInstanceForType { + get { return CustomOptionMaxIntegerValues.DefaultInstance; } + } + + public override CustomOptionMaxIntegerValues BuildPartial() { + CustomOptionMaxIntegerValues returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class CustomOptionOtherValues : pb::GeneratedMessage<CustomOptionOtherValues, CustomOptionOtherValues.Builder> { + private static readonly CustomOptionOtherValues defaultInstance = new Builder().BuildPartial(); + public static CustomOptionOtherValues DefaultInstance { + get { return defaultInstance; } + } + + public override CustomOptionOtherValues DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override CustomOptionOtherValues ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionOtherValues__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<CustomOptionOtherValues, CustomOptionOtherValues.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_CustomOptionOtherValues__FieldAccessorTable; } + } + + public static CustomOptionOtherValues ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static CustomOptionOtherValues ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(CustomOptionOtherValues prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<CustomOptionOtherValues, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + CustomOptionOtherValues result = new CustomOptionOtherValues(); + + protected override CustomOptionOtherValues MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new CustomOptionOtherValues(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return CustomOptionOtherValues.Descriptor; } + } + + public override CustomOptionOtherValues DefaultInstanceForType { + get { return CustomOptionOtherValues.DefaultInstance; } + } + + public override CustomOptionOtherValues BuildPartial() { + CustomOptionOtherValues returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class SettingRealsFromPositiveInts : pb::GeneratedMessage<SettingRealsFromPositiveInts, SettingRealsFromPositiveInts.Builder> { + private static readonly SettingRealsFromPositiveInts defaultInstance = new Builder().BuildPartial(); + public static SettingRealsFromPositiveInts DefaultInstance { + get { return defaultInstance; } + } + + public override SettingRealsFromPositiveInts DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override SettingRealsFromPositiveInts ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_SettingRealsFromPositiveInts__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<SettingRealsFromPositiveInts, SettingRealsFromPositiveInts.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_SettingRealsFromPositiveInts__FieldAccessorTable; } + } + + public static SettingRealsFromPositiveInts ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SettingRealsFromPositiveInts ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SettingRealsFromPositiveInts prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<SettingRealsFromPositiveInts, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + SettingRealsFromPositiveInts result = new SettingRealsFromPositiveInts(); + + protected override SettingRealsFromPositiveInts MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new SettingRealsFromPositiveInts(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return SettingRealsFromPositiveInts.Descriptor; } + } + + public override SettingRealsFromPositiveInts DefaultInstanceForType { + get { return SettingRealsFromPositiveInts.DefaultInstance; } + } + + public override SettingRealsFromPositiveInts BuildPartial() { + SettingRealsFromPositiveInts returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class SettingRealsFromNegativeInts : pb::GeneratedMessage<SettingRealsFromNegativeInts, SettingRealsFromNegativeInts.Builder> { + private static readonly SettingRealsFromNegativeInts defaultInstance = new Builder().BuildPartial(); + public static SettingRealsFromNegativeInts DefaultInstance { + get { return defaultInstance; } + } + + public override SettingRealsFromNegativeInts DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override SettingRealsFromNegativeInts ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_SettingRealsFromNegativeInts__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<SettingRealsFromNegativeInts, SettingRealsFromNegativeInts.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_SettingRealsFromNegativeInts__FieldAccessorTable; } + } + + public static SettingRealsFromNegativeInts ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static SettingRealsFromNegativeInts ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(SettingRealsFromNegativeInts prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<SettingRealsFromNegativeInts, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + SettingRealsFromNegativeInts result = new SettingRealsFromNegativeInts(); + + protected override SettingRealsFromNegativeInts MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new SettingRealsFromNegativeInts(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return SettingRealsFromNegativeInts.Descriptor; } + } + + public override SettingRealsFromNegativeInts DefaultInstanceForType { + get { return SettingRealsFromNegativeInts.DefaultInstance; } + } + + public override SettingRealsFromNegativeInts BuildPartial() { + SettingRealsFromNegativeInts returnMe = result; + result = null; + return returnMe; + } + + } + } + + public sealed partial class ComplexOptionType1 : pb::ExtendableMessage<ComplexOptionType1, ComplexOptionType1.Builder> { + private static readonly ComplexOptionType1 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType1 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType1 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ComplexOptionType1, ComplexOptionType1.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType1__FieldAccessorTable; } + } + + private bool hasFoo; + private int foo_ = 0; + public bool HasFoo { + get { return hasFoo; } + } + public int Foo { + get { return foo_; } + } + + public static ComplexOptionType1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType1 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType1 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<ComplexOptionType1, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType1 result = new ComplexOptionType1(); + + protected override ComplexOptionType1 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType1(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType1.Descriptor; } + } + + public override ComplexOptionType1 DefaultInstanceForType { + get { return ComplexOptionType1.DefaultInstance; } + } + + public override ComplexOptionType1 BuildPartial() { + ComplexOptionType1 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasFoo { + get { return result.HasFoo; } + } + public int Foo { + get { return result.Foo; } + set { SetFoo(value); } + } + public Builder SetFoo(int value) { + result.hasFoo = true; + result.foo_ = value; + return this; + } + public Builder ClearFoo() { + result.hasFoo = false; + result.foo_ = 0; + return this; + } + } + } + + public sealed partial class ComplexOptionType2 : pb::ExtendableMessage<ComplexOptionType2, ComplexOptionType2.Builder> { + private static readonly ComplexOptionType2 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType2 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType2 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType2 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType2__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ComplexOptionType2, ComplexOptionType2.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType2__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class ComplexOptionType4 : pb::GeneratedMessage<ComplexOptionType4, ComplexOptionType4.Builder> { + private static readonly ComplexOptionType4 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType4 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType4 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType4 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ComplexOptionType4, ComplexOptionType4.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType2_ComplexOptionType4__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4> ComplexOpt4 = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4>.CreateInstance(Descriptor.Extensions[0]); + private bool hasWaldo; + private int waldo_ = 0; + public bool HasWaldo { + get { return hasWaldo; } + } + public int Waldo { + get { return waldo_; } + } + + public static ComplexOptionType4 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType4 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType4 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<ComplexOptionType4, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType4 result = new ComplexOptionType4(); + + protected override ComplexOptionType4 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType4(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType4.Descriptor; } + } + + public override ComplexOptionType4 DefaultInstanceForType { + get { return ComplexOptionType4.DefaultInstance; } + } + + public override ComplexOptionType4 BuildPartial() { + ComplexOptionType4 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasWaldo { + get { return result.HasWaldo; } + } + public int Waldo { + get { return result.Waldo; } + set { SetWaldo(value); } + } + public Builder SetWaldo(int value) { + result.hasWaldo = true; + result.waldo_ = value; + return this; + } + public Builder ClearWaldo() { + result.hasWaldo = false; + result.waldo_ = 0; + return this; + } + } + } + + } + #endregion + + private bool hasBar; + private global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 bar_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.DefaultInstance; + public bool HasBar { + get { return hasBar; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 Bar { + get { return bar_; } + } + + private bool hasBaz; + private int baz_ = 0; + public bool HasBaz { + get { return hasBaz; } + } + public int Baz { + get { return baz_; } + } + + private bool hasFred; + private global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 fred_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.DefaultInstance; + public bool HasFred { + get { return hasFred; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 Fred { + get { return fred_; } + } + + public static ComplexOptionType2 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType2 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType2 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<ComplexOptionType2, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType2 result = new ComplexOptionType2(); + + protected override ComplexOptionType2 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType2(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType2.Descriptor; } + } + + public override ComplexOptionType2 DefaultInstanceForType { + get { return ComplexOptionType2.DefaultInstance; } + } + + public override ComplexOptionType2 BuildPartial() { + ComplexOptionType2 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasBar { + get { return result.HasBar; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 Bar { + get { return result.Bar; } + set { SetBar(value); } + } + public Builder SetBar(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 value) { + result.hasBar = true; + result.bar_ = value; + return this; + } + public Builder SetBar(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.Builder builderForValue) { + result.hasBar = true; + result.bar_ = builderForValue.Build(); + return this; + } + public Builder MergeBar(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1 value) { + if (result.HasBar && + result.bar_ != global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.DefaultInstance) { + result.bar_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.CreateBuilder(result.bar_).MergeFrom(value).BuildPartial(); + } else { + result.bar_ = value; + } + result.hasBar = true; + return this; + } + public Builder ClearBar() { + result.hasBar = false; + result.bar_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType1.DefaultInstance; + return this; + } + + public bool HasBaz { + get { return result.HasBaz; } + } + public int Baz { + get { return result.Baz; } + set { SetBaz(value); } + } + public Builder SetBaz(int value) { + result.hasBaz = true; + result.baz_ = value; + return this; + } + public Builder ClearBaz() { + result.hasBaz = false; + result.baz_ = 0; + return this; + } + + public bool HasFred { + get { return result.HasFred; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 Fred { + get { return result.Fred; } + set { SetFred(value); } + } + public Builder SetFred(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 value) { + result.hasFred = true; + result.fred_ = value; + return this; + } + public Builder SetFred(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.Builder builderForValue) { + result.hasFred = true; + result.fred_ = builderForValue.Build(); + return this; + } + public Builder MergeFred(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4 value) { + if (result.HasFred && + result.fred_ != global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.DefaultInstance) { + result.fred_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.CreateBuilder(result.fred_).MergeFrom(value).BuildPartial(); + } else { + result.fred_ = value; + } + result.hasFred = true; + return this; + } + public Builder ClearFred() { + result.hasFred = false; + result.fred_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.DefaultInstance; + return this; + } + } + } + + public sealed partial class ComplexOptionType3 : pb::GeneratedMessage<ComplexOptionType3, ComplexOptionType3.Builder> { + private static readonly ComplexOptionType3 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType3 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType3 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType3 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType3__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ComplexOptionType3, ComplexOptionType3.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType3__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class ComplexOptionType5 : pb::GeneratedMessage<ComplexOptionType5, ComplexOptionType5.Builder> { + private static readonly ComplexOptionType5 defaultInstance = new Builder().BuildPartial(); + public static ComplexOptionType5 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOptionType5 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOptionType5 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ComplexOptionType5, ComplexOptionType5.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOptionType3_ComplexOptionType5__FieldAccessorTable; } + } + + private bool hasPlugh; + private int plugh_ = 0; + public bool HasPlugh { + get { return hasPlugh; } + } + public int Plugh { + get { return plugh_; } + } + + public static ComplexOptionType5 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType5 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType5 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<ComplexOptionType5, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType5 result = new ComplexOptionType5(); + + protected override ComplexOptionType5 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType5(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType5.Descriptor; } + } + + public override ComplexOptionType5 DefaultInstanceForType { + get { return ComplexOptionType5.DefaultInstance; } + } + + public override ComplexOptionType5 BuildPartial() { + ComplexOptionType5 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasPlugh { + get { return result.HasPlugh; } + } + public int Plugh { + get { return result.Plugh; } + set { SetPlugh(value); } + } + public Builder SetPlugh(int value) { + result.hasPlugh = true; + result.plugh_ = value; + return this; + } + public Builder ClearPlugh() { + result.hasPlugh = false; + result.plugh_ = 0; + return this; + } + } + } + + } + #endregion + + private bool hasQux; + private int qux_ = 0; + public bool HasQux { + get { return hasQux; } + } + public int Qux { + get { return qux_; } + } + + private bool hasComplexOptionType5; + private global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 complexOptionType5_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.DefaultInstance; + public bool HasComplexOptionType5 { + get { return hasComplexOptionType5; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 ComplexOptionType5 { + get { return complexOptionType5_; } + } + + public static ComplexOptionType3 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOptionType3 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOptionType3 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<ComplexOptionType3, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOptionType3 result = new ComplexOptionType3(); + + protected override ComplexOptionType3 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOptionType3(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOptionType3.Descriptor; } + } + + public override ComplexOptionType3 DefaultInstanceForType { + get { return ComplexOptionType3.DefaultInstance; } + } + + public override ComplexOptionType3 BuildPartial() { + ComplexOptionType3 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasQux { + get { return result.HasQux; } + } + public int Qux { + get { return result.Qux; } + set { SetQux(value); } + } + public Builder SetQux(int value) { + result.hasQux = true; + result.qux_ = value; + return this; + } + public Builder ClearQux() { + result.hasQux = false; + result.qux_ = 0; + return this; + } + + public bool HasComplexOptionType5 { + get { return result.HasComplexOptionType5; } + } + public global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 ComplexOptionType5 { + get { return result.ComplexOptionType5; } + set { SetComplexOptionType5(value); } + } + public Builder SetComplexOptionType5(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 value) { + result.hasComplexOptionType5 = true; + result.complexOptionType5_ = value; + return this; + } + public Builder SetComplexOptionType5(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.Builder builderForValue) { + result.hasComplexOptionType5 = true; + result.complexOptionType5_ = builderForValue.Build(); + return this; + } + public Builder MergeComplexOptionType5(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5 value) { + if (result.HasComplexOptionType5 && + result.complexOptionType5_ != global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.DefaultInstance) { + result.complexOptionType5_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.CreateBuilder(result.complexOptionType5_).MergeFrom(value).BuildPartial(); + } else { + result.complexOptionType5_ = value; + } + result.hasComplexOptionType5 = true; + return this; + } + public Builder ClearComplexOptionType5() { + result.hasComplexOptionType5 = false; + result.complexOptionType5_ = global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3.Types.ComplexOptionType5.DefaultInstance; + return this; + } + } + } + + public sealed partial class ComplexOpt6 : pb::GeneratedMessage<ComplexOpt6, ComplexOpt6.Builder> { + private static readonly ComplexOpt6 defaultInstance = new Builder().BuildPartial(); + public static ComplexOpt6 DefaultInstance { + get { return defaultInstance; } + } + + public override ComplexOpt6 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ComplexOpt6 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOpt6__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ComplexOpt6, ComplexOpt6.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_ComplexOpt6__FieldAccessorTable; } + } + + private bool hasXyzzy; + private int xyzzy_ = 0; + public bool HasXyzzy { + get { return hasXyzzy; } + } + public int Xyzzy { + get { return xyzzy_; } + } + + public static ComplexOpt6 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ComplexOpt6 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ComplexOpt6 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<ComplexOpt6, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ComplexOpt6 result = new ComplexOpt6(); + + protected override ComplexOpt6 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ComplexOpt6(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ComplexOpt6.Descriptor; } + } + + public override ComplexOpt6 DefaultInstanceForType { + get { return ComplexOpt6.DefaultInstance; } + } + + public override ComplexOpt6 BuildPartial() { + ComplexOpt6 returnMe = result; + result = null; + return returnMe; + } + + + public bool HasXyzzy { + get { return result.HasXyzzy; } + } + public int Xyzzy { + get { return result.Xyzzy; } + set { SetXyzzy(value); } + } + public Builder SetXyzzy(int value) { + result.hasXyzzy = true; + result.xyzzy_ = value; + return this; + } + public Builder ClearXyzzy() { + result.hasXyzzy = false; + result.xyzzy_ = 0; + return this; + } + } + } + + public sealed partial class VariousComplexOptions : pb::GeneratedMessage<VariousComplexOptions, VariousComplexOptions.Builder> { + private static readonly VariousComplexOptions defaultInstance = new Builder().BuildPartial(); + public static VariousComplexOptions DefaultInstance { + get { return defaultInstance; } + } + + public override VariousComplexOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override VariousComplexOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_VariousComplexOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<VariousComplexOptions, VariousComplexOptions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_VariousComplexOptions__FieldAccessorTable; } + } + + public static VariousComplexOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static VariousComplexOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(VariousComplexOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<VariousComplexOptions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + VariousComplexOptions result = new VariousComplexOptions(); + + protected override VariousComplexOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new VariousComplexOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return VariousComplexOptions.Descriptor; } + } + + public override VariousComplexOptions DefaultInstanceForType { + get { return VariousComplexOptions.DefaultInstance; } + } + + public override VariousComplexOptions BuildPartial() { + VariousComplexOptions returnMe = result; + result = null; + return returnMe; + } + + } + } + + #endregion + + #region Services + public abstract class TestServiceWithCustomOptions : pb::IService { + public abstract void Foo( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest request, + global::System.Action<global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse> done); + + public static pbd::ServiceDescriptor Descriptor { + get { return UnitTestCustomOptionsProtoFile.Descriptor.Services[0]; } + } + public pbd::ServiceDescriptor DescriptorForType { + get { return Descriptor; } + } + + public void CallMethod( + pbd::MethodDescriptor method, + pb::IRpcController controller, + pb::IMessage request, + global::System.Action<pb::IMessage> done) { + if (method.Service != Descriptor) { + throw new global::System.ArgumentException( + "Service.CallMethod() given method descriptor for wrong service type."); + } + switch(method.Index) { + case 0: + this.Foo(controller, (global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest) request, + pb::RpcUtil.SpecializeCallback<global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse>( + done)); + return; + default: + throw new global::System.InvalidOperationException("Can't get here."); + } + } + + public pb::IMessage GetRequestPrototype(pbd::MethodDescriptor method) { + if (method.Service != Descriptor) { + throw new global::System.ArgumentException( + "Service.GetRequestPrototype() given method descriptor for wrong service type."); + } + switch(method.Index) { + case 0: + return global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest.DefaultInstance; + default: + throw new global::System.InvalidOperationException("Can't get here."); + } + } + + public pb::IMessage GetResponsePrototype(pbd::MethodDescriptor method) { + if (method.Service != Descriptor) { + throw new global::System.ArgumentException( + "Service.GetResponsePrototype() given method descriptor for wrong service type."); + } + switch(method.Index) { + case 0: + return global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse.DefaultInstance; + default: + throw new global::System.InvalidOperationException("Can't get here."); + } + } + + public static Stub CreateStub(pb::IRpcChannel channel) { + return new Stub(channel); + } + + public class Stub : global::Google.ProtocolBuffers.TestProtos.TestServiceWithCustomOptions { + internal Stub(pb::IRpcChannel channel) { + this.channel = channel; + } + + private readonly pb::IRpcChannel channel; + + public pb::IRpcChannel Channel { + get { return channel; } + } + + public override void Foo( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.CustomOptionFooRequest request, + global::System.Action<global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse> done) { + channel.CallMethod(Descriptor.Methods[0], + controller, request, global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse.DefaultInstance, + pb::RpcUtil.GeneralizeCallback<global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse, global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse.Builder>(done, global::Google.ProtocolBuffers.TestProtos.CustomOptionFooResponse.DefaultInstance)); + } + } + } + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs new file mode 100644 index 00000000..9dcbf1fe --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs @@ -0,0 +1,324 @@ +// 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.TestProtos { + + public static partial class UnitTestEmbedOptimizeForProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "CjFnb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfZW1iZWRfb3B0aW1pemVfZm9y" + + "LnByb3RvEhFwcm90b2J1Zl91bml0dGVzdBokZ29vZ2xlL3Byb3RvYnVmL2Nz" + + "aGFycF9vcHRpb25zLnByb3RvGiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRv" + + "ci5wcm90bxorZ29vZ2xlL3Byb3RvYnVmL3VuaXR0ZXN0X29wdGltaXplX2Zv" + + "ci5wcm90byKhAQoZVGVzdEVtYmVkT3B0aW1pemVkRm9yU2l6ZRJBChBvcHRp" + + "b25hbF9tZXNzYWdlGAEgASgLMicucHJvdG9idWZfdW5pdHRlc3QuVGVzdE9w" + + "dGltaXplZEZvclNpemUSQQoQcmVwZWF0ZWRfbWVzc2FnZRgCIAMoCzInLnBy" + + "b3RvYnVmX3VuaXR0ZXN0LlRlc3RPcHRpbWl6ZWRGb3JTaXplQkxIAYLiCSFH" + + "b29nbGUuUHJvdG9jb2xCdWZmZXJzLlRlc3RQcm90b3OK4gkhVW5pdFRlc3RF" + + "bWJlZE9wdGltaXplRm9yUHJvdG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestEmbedOptimizedForSize__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize.Builder> internal__static_protobuf_unittest_TestEmbedOptimizedForSize__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestEmbedOptimizedForSize.Builder>(internal__static_protobuf_unittest_TestEmbedOptimizedForSize__Descriptor, + new string[] { "OptionalMessage", "RepeatedMessage", }); + #endregion + } + #region Messages + public sealed partial class TestEmbedOptimizedForSize : pb::GeneratedMessage<TestEmbedOptimizedForSize, TestEmbedOptimizedForSize.Builder> { + private static readonly TestEmbedOptimizedForSize defaultInstance = new Builder().BuildPartial(); + public static TestEmbedOptimizedForSize DefaultInstance { + get { return defaultInstance; } + } + + public override TestEmbedOptimizedForSize DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestEmbedOptimizedForSize ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestEmbedOptimizeForProtoFile.internal__static_protobuf_unittest_TestEmbedOptimizedForSize__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestEmbedOptimizedForSize, TestEmbedOptimizedForSize.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestEmbedOptimizeForProtoFile.internal__static_protobuf_unittest_TestEmbedOptimizedForSize__FieldAccessorTable; } + } + + private bool hasOptionalMessage; + private global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance; + public bool HasOptionalMessage { + get { return hasOptionalMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize OptionalMessage { + get { return optionalMessage_; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize> repeatedMessage_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize> RepeatedMessageList { + get { return repeatedMessage_; } + } + public int RepeatedMessageCount { + get { return repeatedMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize GetRepeatedMessage(int index) { + return repeatedMessage_[index]; + } + + public override bool IsInitialized { + get { + if (HasOptionalMessage) { + if (!OptionalMessage.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize element in RepeatedMessageList) { + if (!element.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasOptionalMessage) { + output.WriteMessage(1, OptionalMessage); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize element in RepeatedMessageList) { + output.WriteMessage(2, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasOptionalMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(1, OptionalMessage); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize element in RepeatedMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestEmbedOptimizedForSize ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmbedOptimizedForSize ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestEmbedOptimizedForSize prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestEmbedOptimizedForSize, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestEmbedOptimizedForSize result = new TestEmbedOptimizedForSize(); + + protected override TestEmbedOptimizedForSize MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestEmbedOptimizedForSize(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestEmbedOptimizedForSize.Descriptor; } + } + + public override TestEmbedOptimizedForSize DefaultInstanceForType { + get { return TestEmbedOptimizedForSize.DefaultInstance; } + } + + public override TestEmbedOptimizedForSize BuildPartial() { + result.repeatedMessage_.MakeReadOnly(); + TestEmbedOptimizedForSize returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestEmbedOptimizedForSize) { + return MergeFrom((TestEmbedOptimizedForSize) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestEmbedOptimizedForSize other) { + if (other == TestEmbedOptimizedForSize.DefaultInstance) return this; + if (other.HasOptionalMessage) { + MergeOptionalMessage(other.OptionalMessage); + } + if (other.repeatedMessage_.Count != 0) { + base.AddRange(other.repeatedMessage_, result.repeatedMessage_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder(); + if (HasOptionalMessage) { + subBuilder.MergeFrom(OptionalMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalMessage = subBuilder.BuildPartial(); + break; + } + case 18: { + global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedMessage(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public bool HasOptionalMessage { + get { return result.HasOptionalMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize OptionalMessage { + get { return result.OptionalMessage; } + set { SetOptionalMessage(value); } + } + public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) { + result.hasOptionalMessage = true; + result.optionalMessage_ = value; + return this; + } + public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder builderForValue) { + result.hasOptionalMessage = true; + result.optionalMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) { + if (result.HasOptionalMessage && + result.optionalMessage_ != global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance) { + result.optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.CreateBuilder(result.optionalMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalMessage_ = value; + } + result.hasOptionalMessage = true; + return this; + } + public Builder ClearOptionalMessage() { + result.hasOptionalMessage = false; + result.optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.DefaultInstance; + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize> RepeatedMessageList { + get { return result.repeatedMessage_; } + } + public int RepeatedMessageCount { + get { return result.RepeatedMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize GetRepeatedMessage(int index) { + return result.GetRepeatedMessage(index); + } + public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) { + result.repeatedMessage_[index] = value; + return this; + } + public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder builderForValue) { + result.repeatedMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize value) { + result.repeatedMessage_.Add(value); + return this; + } + public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder builderForValue) { + result.repeatedMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedMessage(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize> values) { + base.AddRange(values, result.repeatedMessage_); + return this; + } + public Builder ClearRepeatedMessage() { + result.repeatedMessage_.Clear(); + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs new file mode 100644 index 00000000..c8f5bef2 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestImportProtoFile.cs @@ -0,0 +1,243 @@ +// 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.TestProtos { + + public static partial class UnitTestImportProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "CiVnb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfaW1wb3J0LnByb3RvEhhwcm90" + + "b2J1Zl91bml0dGVzdF9pbXBvcnQaJGdvb2dsZS9wcm90b2J1Zi9jc2hhcnBf" + + "b3B0aW9ucy5wcm90bxogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJv" + + "dG8iGgoNSW1wb3J0TWVzc2FnZRIJCgFkGAEgASgFKjwKCkltcG9ydEVudW0S" + + "DgoKSU1QT1JUX0ZPTxAHEg4KCklNUE9SVF9CQVIQCBIOCgpJTVBPUlRfQkFa" + + "EAlCXAoYY29tLmdvb2dsZS5wcm90b2J1Zi50ZXN0SAGC4gkhR29vZ2xlLlBy" + + "b3RvY29sQnVmZmVycy5UZXN0UHJvdG9ziuIJF1VuaXRUZXN0SW1wb3J0UHJv" + + "dG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_import_ImportMessage__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ImportMessage, global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder> internal__static_protobuf_unittest_import_ImportMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ImportMessage, global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder>(internal__static_protobuf_unittest_import_ImportMessage__Descriptor, + new string[] { "D", }); + #endregion + } + #region Enums + public enum ImportEnum { + IMPORT_FOO = 7, + IMPORT_BAR = 8, + IMPORT_BAZ = 9, + } + + #endregion + + #region Messages + public sealed partial class ImportMessage : pb::GeneratedMessage<ImportMessage, ImportMessage.Builder> { + private static readonly ImportMessage defaultInstance = new Builder().BuildPartial(); + public static ImportMessage DefaultInstance { + get { return defaultInstance; } + } + + public override ImportMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ImportMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.internal__static_protobuf_unittest_import_ImportMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ImportMessage, ImportMessage.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.internal__static_protobuf_unittest_import_ImportMessage__FieldAccessorTable; } + } + + private bool hasD; + private int d_ = 0; + public bool HasD { + get { return hasD; } + } + public int D { + get { return d_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasD) { + output.WriteInt32(1, D); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasD) { + size += pb::CodedOutputStream.ComputeInt32Size(1, D); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ImportMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ImportMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ImportMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ImportMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ImportMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ImportMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ImportMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ImportMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ImportMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<ImportMessage, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ImportMessage result = new ImportMessage(); + + protected override ImportMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ImportMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ImportMessage.Descriptor; } + } + + public override ImportMessage DefaultInstanceForType { + get { return ImportMessage.DefaultInstance; } + } + + public override ImportMessage BuildPartial() { + ImportMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ImportMessage) { + return MergeFrom((ImportMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ImportMessage other) { + if (other == ImportMessage.DefaultInstance) return this; + if (other.HasD) { + D = other.D; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + D = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasD { + get { return result.HasD; } + } + public int D { + get { return result.D; } + set { SetD(value); } + } + public Builder SetD(int value) { + result.hasD = true; + result.d_ = value; + return this; + } + public Builder ClearD() { + result.hasD = false; + result.d_ = 0; + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs new file mode 100644 index 00000000..72b06d33 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs @@ -0,0 +1,1284 @@ +// 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.TestProtos { + + public static partial class UnitTestMessageSetProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "CiNnb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfbXNldC5wcm90bxIRcHJvdG9i" + + "dWZfdW5pdHRlc3QaJGdvb2dsZS9wcm90b2J1Zi9jc2hhcnBfb3B0aW9ucy5w" + + "cm90bxogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG8iHgoOVGVz" + + "dE1lc3NhZ2VTZXQqCAgEEICAgIACOgIIASJRChdUZXN0TWVzc2FnZVNldENv" + + "bnRhaW5lchI2CgttZXNzYWdlX3NldBgBIAEoCzIhLnByb3RvYnVmX3VuaXR0" + + "ZXN0LlRlc3RNZXNzYWdlU2V0IpYBChhUZXN0TWVzc2FnZVNldEV4dGVuc2lv" + + "bjESCQoBaRgPIAEoBTJvChVtZXNzYWdlX3NldF9leHRlbnNpb24SIS5wcm90" + + "b2J1Zl91bml0dGVzdC5UZXN0TWVzc2FnZVNldBiwpl4gASgLMisucHJvdG9i" + + "dWZfdW5pdHRlc3QuVGVzdE1lc3NhZ2VTZXRFeHRlbnNpb24xIpgBChhUZXN0" + + "TWVzc2FnZVNldEV4dGVuc2lvbjISCwoDc3RyGBkgASgJMm8KFW1lc3NhZ2Vf" + + "c2V0X2V4dGVuc2lvbhIhLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RNZXNzYWdl" + + "U2V0GPm7XiABKAsyKy5wcm90b2J1Zl91bml0dGVzdC5UZXN0TWVzc2FnZVNl" + + "dEV4dGVuc2lvbjIibgoNUmF3TWVzc2FnZVNldBIzCgRpdGVtGAEgAygKMiUu" + + "cHJvdG9idWZfdW5pdHRlc3QuUmF3TWVzc2FnZVNldC5JdGVtGigKBEl0ZW0S" + + "DwoHdHlwZV9pZBgCIAIoBRIPCgdtZXNzYWdlGAMgAigMQkZIAYLiCSFHb29n" + + "bGUuUHJvdG9jb2xCdWZmZXJzLlRlc3RQcm90b3OK4gkbVW5pdFRlc3RNZXNz" + + "YWdlU2V0UHJvdG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageSet__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageSet, global::Google.ProtocolBuffers.TestProtos.TestMessageSet.Builder> internal__static_protobuf_unittest_TestMessageSet__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageSet, global::Google.ProtocolBuffers.TestProtos.TestMessageSet.Builder>(internal__static_protobuf_unittest_TestMessageSet__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageSetContainer__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageSetContainer, global::Google.ProtocolBuffers.TestProtos.TestMessageSetContainer.Builder> internal__static_protobuf_unittest_TestMessageSetContainer__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageSetContainer, global::Google.ProtocolBuffers.TestProtos.TestMessageSetContainer.Builder>(internal__static_protobuf_unittest_TestMessageSetContainer__Descriptor, + new string[] { "MessageSet", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageSetExtension1__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension1, global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension1.Builder> internal__static_protobuf_unittest_TestMessageSetExtension1__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension1, global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension1.Builder>(internal__static_protobuf_unittest_TestMessageSetExtension1__Descriptor, + new string[] { "I", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageSetExtension2__Descriptor + = Descriptor.MessageTypes[3]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension2, global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension2.Builder> internal__static_protobuf_unittest_TestMessageSetExtension2__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension2, global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension2.Builder>(internal__static_protobuf_unittest_TestMessageSetExtension2__Descriptor, + new string[] { "Str", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_RawMessageSet__Descriptor + = Descriptor.MessageTypes[4]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.RawMessageSet, global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Builder> internal__static_protobuf_unittest_RawMessageSet__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.RawMessageSet, global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Builder>(internal__static_protobuf_unittest_RawMessageSet__Descriptor, + new string[] { "Item", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_RawMessageSet_Item__Descriptor + = internal__static_protobuf_unittest_RawMessageSet__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item, global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.Builder> internal__static_protobuf_unittest_RawMessageSet_Item__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item, global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.Builder>(internal__static_protobuf_unittest_RawMessageSet_Item__Descriptor, + new string[] { "TypeId", "Message", }); + #endregion + } + #region Messages + public sealed partial class TestMessageSet : pb::ExtendableMessage<TestMessageSet, TestMessageSet.Builder> { + private static readonly TestMessageSet defaultInstance = new Builder().BuildPartial(); + public static TestMessageSet DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageSet DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageSet ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSet__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestMessageSet, TestMessageSet.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSet__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<TestMessageSet, TestMessageSet.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteAsMessageSetTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSizeAsMessageSet; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMessageSet ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSet ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSet ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageSet ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageSet prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<TestMessageSet, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageSet result = new TestMessageSet(); + + protected override TestMessageSet MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageSet(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageSet.Descriptor; } + } + + public override TestMessageSet DefaultInstanceForType { + get { return TestMessageSet.DefaultInstance; } + } + + public override TestMessageSet BuildPartial() { + TestMessageSet returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMessageSet) { + return MergeFrom((TestMessageSet) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMessageSet other) { + if (other == TestMessageSet.DefaultInstance) return this; + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class TestMessageSetContainer : pb::GeneratedMessage<TestMessageSetContainer, TestMessageSetContainer.Builder> { + private static readonly TestMessageSetContainer defaultInstance = new Builder().BuildPartial(); + public static TestMessageSetContainer DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageSetContainer DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageSetContainer ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetContainer__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestMessageSetContainer, TestMessageSetContainer.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetContainer__FieldAccessorTable; } + } + + private bool hasMessageSet; + private global::Google.ProtocolBuffers.TestProtos.TestMessageSet messageSet_ = global::Google.ProtocolBuffers.TestProtos.TestMessageSet.DefaultInstance; + public bool HasMessageSet { + get { return hasMessageSet; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMessageSet MessageSet { + get { return messageSet_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasMessageSet) { + output.WriteMessage(1, MessageSet); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasMessageSet) { + size += pb::CodedOutputStream.ComputeMessageSize(1, MessageSet); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMessageSetContainer ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetContainer ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageSetContainer prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestMessageSetContainer, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageSetContainer result = new TestMessageSetContainer(); + + protected override TestMessageSetContainer MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageSetContainer(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageSetContainer.Descriptor; } + } + + public override TestMessageSetContainer DefaultInstanceForType { + get { return TestMessageSetContainer.DefaultInstance; } + } + + public override TestMessageSetContainer BuildPartial() { + TestMessageSetContainer returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMessageSetContainer) { + return MergeFrom((TestMessageSetContainer) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMessageSetContainer other) { + if (other == TestMessageSetContainer.DefaultInstance) return this; + if (other.HasMessageSet) { + MergeMessageSet(other.MessageSet); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestMessageSet.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestMessageSet.CreateBuilder(); + if (HasMessageSet) { + subBuilder.MergeFrom(MessageSet); + } + input.ReadMessage(subBuilder, extensionRegistry); + MessageSet = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasMessageSet { + get { return result.HasMessageSet; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMessageSet MessageSet { + get { return result.MessageSet; } + set { SetMessageSet(value); } + } + public Builder SetMessageSet(global::Google.ProtocolBuffers.TestProtos.TestMessageSet value) { + result.hasMessageSet = true; + result.messageSet_ = value; + return this; + } + public Builder SetMessageSet(global::Google.ProtocolBuffers.TestProtos.TestMessageSet.Builder builderForValue) { + result.hasMessageSet = true; + result.messageSet_ = builderForValue.Build(); + return this; + } + public Builder MergeMessageSet(global::Google.ProtocolBuffers.TestProtos.TestMessageSet value) { + if (result.HasMessageSet && + result.messageSet_ != global::Google.ProtocolBuffers.TestProtos.TestMessageSet.DefaultInstance) { + result.messageSet_ = global::Google.ProtocolBuffers.TestProtos.TestMessageSet.CreateBuilder(result.messageSet_).MergeFrom(value).BuildPartial(); + } else { + result.messageSet_ = value; + } + result.hasMessageSet = true; + return this; + } + public Builder ClearMessageSet() { + result.hasMessageSet = false; + result.messageSet_ = global::Google.ProtocolBuffers.TestProtos.TestMessageSet.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestMessageSetExtension1 : pb::GeneratedMessage<TestMessageSetExtension1, TestMessageSetExtension1.Builder> { + private static readonly TestMessageSetExtension1 defaultInstance = new Builder().BuildPartial(); + public static TestMessageSetExtension1 DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageSetExtension1 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageSetExtension1 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetExtension1__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestMessageSetExtension1, TestMessageSetExtension1.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetExtension1__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension1> MessageSetExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension1>.CreateInstance(Descriptor.Extensions[0]); + private bool hasI; + private int i_ = 0; + public bool HasI { + get { return hasI; } + } + public int I { + get { return i_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasI) { + output.WriteInt32(15, I); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasI) { + size += pb::CodedOutputStream.ComputeInt32Size(15, I); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMessageSetExtension1 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetExtension1 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageSetExtension1 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestMessageSetExtension1, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageSetExtension1 result = new TestMessageSetExtension1(); + + protected override TestMessageSetExtension1 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageSetExtension1(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageSetExtension1.Descriptor; } + } + + public override TestMessageSetExtension1 DefaultInstanceForType { + get { return TestMessageSetExtension1.DefaultInstance; } + } + + public override TestMessageSetExtension1 BuildPartial() { + TestMessageSetExtension1 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMessageSetExtension1) { + return MergeFrom((TestMessageSetExtension1) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMessageSetExtension1 other) { + if (other == TestMessageSetExtension1.DefaultInstance) return this; + if (other.HasI) { + I = other.I; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 120: { + I = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasI { + get { return result.HasI; } + } + public int I { + get { return result.I; } + set { SetI(value); } + } + public Builder SetI(int value) { + result.hasI = true; + result.i_ = value; + return this; + } + public Builder ClearI() { + result.hasI = false; + result.i_ = 0; + return this; + } + } + } + + public sealed partial class TestMessageSetExtension2 : pb::GeneratedMessage<TestMessageSetExtension2, TestMessageSetExtension2.Builder> { + private static readonly TestMessageSetExtension2 defaultInstance = new Builder().BuildPartial(); + public static TestMessageSetExtension2 DefaultInstance { + get { return defaultInstance; } + } + + public override TestMessageSetExtension2 DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMessageSetExtension2 ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetExtension2__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestMessageSetExtension2, TestMessageSetExtension2.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_TestMessageSetExtension2__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension2> MessageSetExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.TestMessageSetExtension2>.CreateInstance(Descriptor.Extensions[0]); + private bool hasStr; + private string str_ = ""; + public bool HasStr { + get { return hasStr; } + } + public string Str { + get { return str_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasStr) { + output.WriteString(25, Str); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasStr) { + size += pb::CodedOutputStream.ComputeStringSize(25, Str); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMessageSetExtension2 ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMessageSetExtension2 ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMessageSetExtension2 prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestMessageSetExtension2, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMessageSetExtension2 result = new TestMessageSetExtension2(); + + protected override TestMessageSetExtension2 MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMessageSetExtension2(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMessageSetExtension2.Descriptor; } + } + + public override TestMessageSetExtension2 DefaultInstanceForType { + get { return TestMessageSetExtension2.DefaultInstance; } + } + + public override TestMessageSetExtension2 BuildPartial() { + TestMessageSetExtension2 returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMessageSetExtension2) { + return MergeFrom((TestMessageSetExtension2) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMessageSetExtension2 other) { + if (other == TestMessageSetExtension2.DefaultInstance) return this; + if (other.HasStr) { + Str = other.Str; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 202: { + Str = input.ReadString(); + break; + } + } + } + } + + + public bool HasStr { + get { return result.HasStr; } + } + public string Str { + get { return result.Str; } + set { SetStr(value); } + } + public Builder SetStr(string value) { + result.hasStr = true; + result.str_ = value; + return this; + } + public Builder ClearStr() { + result.hasStr = false; + result.str_ = ""; + return this; + } + } + } + + public sealed partial class RawMessageSet : pb::GeneratedMessage<RawMessageSet, RawMessageSet.Builder> { + private static readonly RawMessageSet defaultInstance = new Builder().BuildPartial(); + public static RawMessageSet DefaultInstance { + get { return defaultInstance; } + } + + public override RawMessageSet DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override RawMessageSet ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_RawMessageSet__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<RawMessageSet, RawMessageSet.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_RawMessageSet__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class Item : pb::GeneratedMessage<Item, Item.Builder> { + private static readonly Item defaultInstance = new Builder().BuildPartial(); + public static Item DefaultInstance { + get { return defaultInstance; } + } + + public override Item DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Item ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_RawMessageSet_Item__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<Item, Item.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestMessageSetProtoFile.internal__static_protobuf_unittest_RawMessageSet_Item__FieldAccessorTable; } + } + + private bool hasTypeId; + private int typeId_ = 0; + public bool HasTypeId { + get { return hasTypeId; } + } + public int TypeId { + get { return typeId_; } + } + + private bool hasMessage; + private pb::ByteString message_ = pb::ByteString.Empty; + public bool HasMessage { + get { return hasMessage; } + } + public pb::ByteString Message { + get { return message_; } + } + + public override bool IsInitialized { + get { + if (!hasTypeId) return false; + if (!hasMessage) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasTypeId) { + output.WriteInt32(2, TypeId); + } + if (HasMessage) { + output.WriteBytes(3, Message); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasTypeId) { + size += pb::CodedOutputStream.ComputeInt32Size(2, TypeId); + } + if (HasMessage) { + size += pb::CodedOutputStream.ComputeBytesSize(3, Message); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Item ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Item ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Item ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Item ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Item ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Item ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Item ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Item ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Item prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<Item, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Item result = new Item(); + + protected override Item MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Item(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Item.Descriptor; } + } + + public override Item DefaultInstanceForType { + get { return Item.DefaultInstance; } + } + + public override Item BuildPartial() { + Item returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Item) { + return MergeFrom((Item) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Item other) { + if (other == Item.DefaultInstance) return this; + if (other.HasTypeId) { + TypeId = other.TypeId; + } + if (other.HasMessage) { + Message = other.Message; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 16: { + TypeId = input.ReadInt32(); + break; + } + case 26: { + Message = input.ReadBytes(); + break; + } + } + } + } + + + public bool HasTypeId { + get { return result.HasTypeId; } + } + public int TypeId { + get { return result.TypeId; } + set { SetTypeId(value); } + } + public Builder SetTypeId(int value) { + result.hasTypeId = true; + result.typeId_ = value; + return this; + } + public Builder ClearTypeId() { + result.hasTypeId = false; + result.typeId_ = 0; + return this; + } + + public bool HasMessage { + get { return result.HasMessage; } + } + public pb::ByteString Message { + get { return result.Message; } + set { SetMessage(value); } + } + public Builder SetMessage(pb::ByteString value) { + result.hasMessage = true; + result.message_ = value; + return this; + } + public Builder ClearMessage() { + result.hasMessage = false; + result.message_ = pb::ByteString.Empty; + return this; + } + } + } + + } + #endregion + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item> item_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item> ItemList { + get { return item_; } + } + public int ItemCount { + get { return item_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item GetItem(int index) { + return item_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item element in ItemList) { + output.WriteGroup(1, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item element in ItemList) { + size += pb::CodedOutputStream.ComputeGroupSize(1, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static RawMessageSet ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RawMessageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RawMessageSet ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RawMessageSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RawMessageSet ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RawMessageSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static RawMessageSet ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RawMessageSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(RawMessageSet prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<RawMessageSet, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + RawMessageSet result = new RawMessageSet(); + + protected override RawMessageSet MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new RawMessageSet(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return RawMessageSet.Descriptor; } + } + + public override RawMessageSet DefaultInstanceForType { + get { return RawMessageSet.DefaultInstance; } + } + + public override RawMessageSet BuildPartial() { + result.item_.MakeReadOnly(); + RawMessageSet returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is RawMessageSet) { + return MergeFrom((RawMessageSet) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(RawMessageSet other) { + if (other == RawMessageSet.DefaultInstance) return this; + if (other.item_.Count != 0) { + base.AddRange(other.item_, result.item_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 11: { + global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.CreateBuilder(); + input.ReadGroup(1, subBuilder, extensionRegistry); + AddItem(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item> ItemList { + get { return result.item_; } + } + public int ItemCount { + get { return result.ItemCount; } + } + public global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item GetItem(int index) { + return result.GetItem(index); + } + public Builder SetItem(int index, global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item value) { + result.item_[index] = value; + return this; + } + public Builder SetItem(int index, global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.Builder builderForValue) { + result.item_[index] = builderForValue.Build(); + return this; + } + public Builder AddItem(global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item value) { + result.item_.Add(value); + return this; + } + public Builder AddItem(global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item.Builder builderForValue) { + result.item_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeItem(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.RawMessageSet.Types.Item> values) { + base.AddRange(values, result.item_); + return this; + } + public Builder ClearItem() { + result.item_.Clear(); + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs new file mode 100644 index 00000000..135e7a2f --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestOptimizeForProtoFile.cs @@ -0,0 +1,467 @@ +// 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.TestProtos { + + public static partial class UnitTestOptimizeForProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "Citnb29nbGUvcHJvdG9idWYvdW5pdHRlc3Rfb3B0aW1pemVfZm9yLnByb3Rv" + + "EhFwcm90b2J1Zl91bml0dGVzdBokZ29vZ2xlL3Byb3RvYnVmL2NzaGFycF9v" + + "cHRpb25zLnByb3RvGiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90" + + "bxoeZ29vZ2xlL3Byb3RvYnVmL3VuaXR0ZXN0LnByb3RvIp4BChRUZXN0T3B0" + + "aW1pemVkRm9yU2l6ZRIJCgFpGAEgASgFEi4KA21zZxgTIAEoCzIhLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LkZvcmVpZ25NZXNzYWdlKgkI6AcQgICAgAIyQAoOdGVz" + + "dF9leHRlbnNpb24SJy5wcm90b2J1Zl91bml0dGVzdC5UZXN0T3B0aW1pemVk" + + "Rm9yU2l6ZRjSCSABKAUiKQocVGVzdFJlcXVpcmVkT3B0aW1pemVkRm9yU2l6" + + "ZRIJCgF4GAEgAigFIloKHFRlc3RPcHRpb25hbE9wdGltaXplZEZvclNpemUS" + + "OgoBbxgBIAEoCzIvLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RSZXF1aXJlZE9w" + + "dGltaXplZEZvclNpemVCR0gCguIJIUdvb2dsZS5Qcm90b2NvbEJ1ZmZlcnMu" + + "VGVzdFByb3Rvc4riCRxVbml0VGVzdE9wdGltaXplRm9yUHJvdG9GaWxl"), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.Descriptor, + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestOptimizedForSize__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder> internal__static_protobuf_unittest_TestOptimizedForSize__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestOptimizedForSize.Builder>(internal__static_protobuf_unittest_TestOptimizedForSize__Descriptor, + new string[] { "I", "Msg", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestRequiredOptimizedForSize__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.Builder> internal__static_protobuf_unittest_TestRequiredOptimizedForSize__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.Builder>(internal__static_protobuf_unittest_TestRequiredOptimizedForSize__Descriptor, + new string[] { "X", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestOptionalOptimizedForSize__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize.Builder> internal__static_protobuf_unittest_TestOptionalOptimizedForSize__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize, global::Google.ProtocolBuffers.TestProtos.TestOptionalOptimizedForSize.Builder>(internal__static_protobuf_unittest_TestOptionalOptimizedForSize__Descriptor, + new string[] { "O", }); + #endregion + } + #region Messages + public sealed partial class TestOptimizedForSize : pb::ExtendableMessage<TestOptimizedForSize, TestOptimizedForSize.Builder> { + private static readonly TestOptimizedForSize defaultInstance = new Builder().BuildPartial(); + public static TestOptimizedForSize DefaultInstance { + get { return defaultInstance; } + } + + public override TestOptimizedForSize DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestOptimizedForSize ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptimizedForSize__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestOptimizedForSize, TestOptimizedForSize.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptimizedForSize__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase<int> TestExtension = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[0]); + private bool hasI; + private int i_ = 0; + public bool HasI { + get { return hasI; } + } + public int I { + get { return i_; } + } + + private bool hasMsg; + private global::Google.ProtocolBuffers.TestProtos.ForeignMessage msg_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + public bool HasMsg { + get { return hasMsg; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage Msg { + get { return msg_; } + } + + public static TestOptimizedForSize ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestOptimizedForSize ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestOptimizedForSize prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<TestOptimizedForSize, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestOptimizedForSize result = new TestOptimizedForSize(); + + protected override TestOptimizedForSize MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestOptimizedForSize(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestOptimizedForSize.Descriptor; } + } + + public override TestOptimizedForSize DefaultInstanceForType { + get { return TestOptimizedForSize.DefaultInstance; } + } + + public override TestOptimizedForSize BuildPartial() { + TestOptimizedForSize returnMe = result; + result = null; + return returnMe; + } + + + public bool HasI { + get { return result.HasI; } + } + public int I { + get { return result.I; } + set { SetI(value); } + } + public Builder SetI(int value) { + result.hasI = true; + result.i_ = value; + return this; + } + public Builder ClearI() { + result.hasI = false; + result.i_ = 0; + return this; + } + + public bool HasMsg { + get { return result.HasMsg; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage Msg { + get { return result.Msg; } + set { SetMsg(value); } + } + public Builder SetMsg(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.hasMsg = true; + result.msg_ = value; + return this; + } + public Builder SetMsg(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.hasMsg = true; + result.msg_ = builderForValue.Build(); + return this; + } + public Builder MergeMsg(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + if (result.HasMsg && + result.msg_ != global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance) { + result.msg_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(result.msg_).MergeFrom(value).BuildPartial(); + } else { + result.msg_ = value; + } + result.hasMsg = true; + return this; + } + public Builder ClearMsg() { + result.hasMsg = false; + result.msg_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestRequiredOptimizedForSize : pb::GeneratedMessage<TestRequiredOptimizedForSize, TestRequiredOptimizedForSize.Builder> { + private static readonly TestRequiredOptimizedForSize defaultInstance = new Builder().BuildPartial(); + public static TestRequiredOptimizedForSize DefaultInstance { + get { return defaultInstance; } + } + + public override TestRequiredOptimizedForSize DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestRequiredOptimizedForSize ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestRequiredOptimizedForSize__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestRequiredOptimizedForSize, TestRequiredOptimizedForSize.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestRequiredOptimizedForSize__FieldAccessorTable; } + } + + private bool hasX; + private int x_ = 0; + public bool HasX { + get { return hasX; } + } + public int X { + get { return x_; } + } + + public static TestRequiredOptimizedForSize ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequiredOptimizedForSize ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestRequiredOptimizedForSize prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestRequiredOptimizedForSize, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestRequiredOptimizedForSize result = new TestRequiredOptimizedForSize(); + + protected override TestRequiredOptimizedForSize MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestRequiredOptimizedForSize(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestRequiredOptimizedForSize.Descriptor; } + } + + public override TestRequiredOptimizedForSize DefaultInstanceForType { + get { return TestRequiredOptimizedForSize.DefaultInstance; } + } + + public override TestRequiredOptimizedForSize BuildPartial() { + TestRequiredOptimizedForSize returnMe = result; + result = null; + return returnMe; + } + + + public bool HasX { + get { return result.HasX; } + } + public int X { + get { return result.X; } + set { SetX(value); } + } + public Builder SetX(int value) { + result.hasX = true; + result.x_ = value; + return this; + } + public Builder ClearX() { + result.hasX = false; + result.x_ = 0; + return this; + } + } + } + + public sealed partial class TestOptionalOptimizedForSize : pb::GeneratedMessage<TestOptionalOptimizedForSize, TestOptionalOptimizedForSize.Builder> { + private static readonly TestOptionalOptimizedForSize defaultInstance = new Builder().BuildPartial(); + public static TestOptionalOptimizedForSize DefaultInstance { + get { return defaultInstance; } + } + + public override TestOptionalOptimizedForSize DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestOptionalOptimizedForSize ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptionalOptimizedForSize__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestOptionalOptimizedForSize, TestOptionalOptimizedForSize.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestOptimizeForProtoFile.internal__static_protobuf_unittest_TestOptionalOptimizedForSize__FieldAccessorTable; } + } + + private bool hasO; + private global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize o_ = global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance; + public bool HasO { + get { return hasO; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize O { + get { return o_; } + } + + public static TestOptionalOptimizedForSize ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestOptionalOptimizedForSize ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestOptionalOptimizedForSize prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestOptionalOptimizedForSize, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestOptionalOptimizedForSize result = new TestOptionalOptimizedForSize(); + + protected override TestOptionalOptimizedForSize MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestOptionalOptimizedForSize(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestOptionalOptimizedForSize.Descriptor; } + } + + public override TestOptionalOptimizedForSize DefaultInstanceForType { + get { return TestOptionalOptimizedForSize.DefaultInstance; } + } + + public override TestOptionalOptimizedForSize BuildPartial() { + TestOptionalOptimizedForSize returnMe = result; + result = null; + return returnMe; + } + + + public bool HasO { + get { return result.HasO; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize O { + get { return result.O; } + set { SetO(value); } + } + public Builder SetO(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize value) { + result.hasO = true; + result.o_ = value; + return this; + } + public Builder SetO(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.Builder builderForValue) { + result.hasO = true; + result.o_ = builderForValue.Build(); + return this; + } + public Builder MergeO(global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize value) { + if (result.HasO && + result.o_ != global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance) { + result.o_ = global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.CreateBuilder(result.o_).MergeFrom(value).BuildPartial(); + } else { + result.o_ = value; + } + result.hasO = true; + return this; + } + public Builder ClearO() { + result.hasO = false; + result.o_ = global::Google.ProtocolBuffers.TestProtos.TestRequiredOptimizedForSize.DefaultInstance; + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs b/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs new file mode 100644 index 00000000..9e706b02 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs @@ -0,0 +1,11835 @@ +// 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.TestProtos { + + public static partial class UnitTestProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "Ch5nb29nbGUvcHJvdG9idWYvdW5pdHRlc3QucHJvdG8SEXByb3RvYnVmX3Vu" + + "aXR0ZXN0GiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8a" + + "IGdvb2dsZS9wcm90b2J1Zi9kZXNjcmlwdG9yLnByb3RvGiVnb29nbGUvcHJv" + + "dG9idWYvdW5pdHRlc3RfaW1wb3J0LnByb3RvIrsVCgxUZXN0QWxsVHlwZXMS" + + "FgoOb3B0aW9uYWxfaW50MzIYASABKAUSFgoOb3B0aW9uYWxfaW50NjQYAiAB" + + "KAMSFwoPb3B0aW9uYWxfdWludDMyGAMgASgNEhcKD29wdGlvbmFsX3VpbnQ2" + + "NBgEIAEoBBIXCg9vcHRpb25hbF9zaW50MzIYBSABKBESFwoPb3B0aW9uYWxf" + + "c2ludDY0GAYgASgSEhgKEG9wdGlvbmFsX2ZpeGVkMzIYByABKAcSGAoQb3B0" + + "aW9uYWxfZml4ZWQ2NBgIIAEoBhIZChFvcHRpb25hbF9zZml4ZWQzMhgJIAEo" + + "DxIZChFvcHRpb25hbF9zZml4ZWQ2NBgKIAEoEBIWCg5vcHRpb25hbF9mbG9h" + + "dBgLIAEoAhIXCg9vcHRpb25hbF9kb3VibGUYDCABKAESFQoNb3B0aW9uYWxf" + + "Ym9vbBgNIAEoCBIXCg9vcHRpb25hbF9zdHJpbmcYDiABKAkSFgoOb3B0aW9u" + + "YWxfYnl0ZXMYDyABKAwSRAoNb3B0aW9uYWxncm91cBgQIAEoCjItLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxUeXBlcy5PcHRpb25hbEdyb3VwEk4KF29w" + + "dGlvbmFsX25lc3RlZF9tZXNzYWdlGBIgASgLMi0ucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbFR5cGVzLk5lc3RlZE1lc3NhZ2USQwoYb3B0aW9uYWxfZm9y" + + "ZWlnbl9tZXNzYWdlGBMgASgLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWln" + + "bk1lc3NhZ2USSAoXb3B0aW9uYWxfaW1wb3J0X21lc3NhZ2UYFCABKAsyJy5w" + + "cm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0TWVzc2FnZRJIChRvcHRp" + + "b25hbF9uZXN0ZWRfZW51bRgVIAEoDjIqLnByb3RvYnVmX3VuaXR0ZXN0LlRl" + + "c3RBbGxUeXBlcy5OZXN0ZWRFbnVtEj0KFW9wdGlvbmFsX2ZvcmVpZ25fZW51" + + "bRgWIAEoDjIeLnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25FbnVtEkIKFG9w" + + "dGlvbmFsX2ltcG9ydF9lbnVtGBcgASgOMiQucHJvdG9idWZfdW5pdHRlc3Rf" + + "aW1wb3J0LkltcG9ydEVudW0SIQoVb3B0aW9uYWxfc3RyaW5nX3BpZWNlGBgg" + + "ASgJQgIIAhIZCg1vcHRpb25hbF9jb3JkGBkgASgJQgIIARIWCg5yZXBlYXRl" + + "ZF9pbnQzMhgfIAMoBRIWCg5yZXBlYXRlZF9pbnQ2NBggIAMoAxIXCg9yZXBl" + + "YXRlZF91aW50MzIYISADKA0SFwoPcmVwZWF0ZWRfdWludDY0GCIgAygEEhcK" + + "D3JlcGVhdGVkX3NpbnQzMhgjIAMoERIXCg9yZXBlYXRlZF9zaW50NjQYJCAD" + + "KBISGAoQcmVwZWF0ZWRfZml4ZWQzMhglIAMoBxIYChByZXBlYXRlZF9maXhl" + + "ZDY0GCYgAygGEhkKEXJlcGVhdGVkX3NmaXhlZDMyGCcgAygPEhkKEXJlcGVh" + + "dGVkX3NmaXhlZDY0GCggAygQEhYKDnJlcGVhdGVkX2Zsb2F0GCkgAygCEhcK" + + "D3JlcGVhdGVkX2RvdWJsZRgqIAMoARIVCg1yZXBlYXRlZF9ib29sGCsgAygI" + + "EhcKD3JlcGVhdGVkX3N0cmluZxgsIAMoCRIWCg5yZXBlYXRlZF9ieXRlcxgt" + + "IAMoDBJECg1yZXBlYXRlZGdyb3VwGC4gAygKMi0ucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbFR5cGVzLlJlcGVhdGVkR3JvdXASTgoXcmVwZWF0ZWRfbmVz" + + "dGVkX21lc3NhZ2UYMCADKAsyLS5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs" + + "VHlwZXMuTmVzdGVkTWVzc2FnZRJDChhyZXBlYXRlZF9mb3JlaWduX21lc3Nh" + + "Z2UYMSADKAsyIS5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWduTWVzc2FnZRJI" + + "ChdyZXBlYXRlZF9pbXBvcnRfbWVzc2FnZRgyIAMoCzInLnByb3RvYnVmX3Vu" + + "aXR0ZXN0X2ltcG9ydC5JbXBvcnRNZXNzYWdlEkgKFHJlcGVhdGVkX25lc3Rl" + + "ZF9lbnVtGDMgAygOMioucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVz" + + "Lk5lc3RlZEVudW0SPQoVcmVwZWF0ZWRfZm9yZWlnbl9lbnVtGDQgAygOMh4u" + + "cHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbkVudW0SQgoUcmVwZWF0ZWRfaW1w" + + "b3J0X2VudW0YNSADKA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1w" + + "b3J0RW51bRIhChVyZXBlYXRlZF9zdHJpbmdfcGllY2UYNiADKAlCAggCEhkK" + + "DXJlcGVhdGVkX2NvcmQYNyADKAlCAggBEhkKDWRlZmF1bHRfaW50MzIYPSAB" + + "KAU6AjQxEhkKDWRlZmF1bHRfaW50NjQYPiABKAM6AjQyEhoKDmRlZmF1bHRf" + + "dWludDMyGD8gASgNOgI0MxIaCg5kZWZhdWx0X3VpbnQ2NBhAIAEoBDoCNDQS" + + "GwoOZGVmYXVsdF9zaW50MzIYQSABKBE6Ay00NRIaCg5kZWZhdWx0X3NpbnQ2" + + "NBhCIAEoEjoCNDYSGwoPZGVmYXVsdF9maXhlZDMyGEMgASgHOgI0NxIbCg9k" + + "ZWZhdWx0X2ZpeGVkNjQYRCABKAY6AjQ4EhwKEGRlZmF1bHRfc2ZpeGVkMzIY" + + "RSABKA86AjQ5Eh0KEGRlZmF1bHRfc2ZpeGVkNjQYRiABKBA6Ay01MBIbCg1k" + + "ZWZhdWx0X2Zsb2F0GEcgASgCOgQ1MS41Eh0KDmRlZmF1bHRfZG91YmxlGEgg" + + "ASgBOgU1MjAwMBIaCgxkZWZhdWx0X2Jvb2wYSSABKAg6BHRydWUSHQoOZGVm" + + "YXVsdF9zdHJpbmcYSiABKAk6BWhlbGxvEhwKDWRlZmF1bHRfYnl0ZXMYSyAB" + + "KAw6BXdvcmxkEkwKE2RlZmF1bHRfbmVzdGVkX2VudW0YUSABKA4yKi5wcm90" + + "b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXMuTmVzdGVkRW51bToDQkFSEkkK" + + "FGRlZmF1bHRfZm9yZWlnbl9lbnVtGFIgASgOMh4ucHJvdG9idWZfdW5pdHRl" + + "c3QuRm9yZWlnbkVudW06C0ZPUkVJR05fQkFSEk0KE2RlZmF1bHRfaW1wb3J0" + + "X2VudW0YUyABKA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0" + + "RW51bToKSU1QT1JUX0JBUhIlChRkZWZhdWx0X3N0cmluZ19waWVjZRhUIAEo" + + "CToDYWJjQgIIAhIdCgxkZWZhdWx0X2NvcmQYVSABKAk6AzEyM0ICCAEaGwoN" + + "TmVzdGVkTWVzc2FnZRIKCgJiYhgBIAEoBRoaCg1PcHRpb25hbEdyb3VwEgkK" + + "AWEYESABKAUaGgoNUmVwZWF0ZWRHcm91cBIJCgFhGC8gASgFIicKCk5lc3Rl" + + "ZEVudW0SBwoDRk9PEAESBwoDQkFSEAISBwoDQkFaEAMiGwoORm9yZWlnbk1l" + + "c3NhZ2USCQoBYxgBIAEoBSIdChFUZXN0QWxsRXh0ZW5zaW9ucyoICAEQgICA" + + "gAIiJAoXT3B0aW9uYWxHcm91cF9leHRlbnNpb24SCQoBYRgRIAEoBSIkChdS" + + "ZXBlYXRlZEdyb3VwX2V4dGVuc2lvbhIJCgFhGC8gASgFItUFCgxUZXN0UmVx" + + "dWlyZWQSCQoBYRgBIAIoBRIOCgZkdW1teTIYAiABKAUSCQoBYhgDIAIoBRIO" + + "CgZkdW1teTQYBCABKAUSDgoGZHVtbXk1GAUgASgFEg4KBmR1bW15NhgGIAEo" + + "BRIOCgZkdW1teTcYByABKAUSDgoGZHVtbXk4GAggASgFEg4KBmR1bW15ORgJ" + + "IAEoBRIPCgdkdW1teTEwGAogASgFEg8KB2R1bW15MTEYCyABKAUSDwoHZHVt" + + "bXkxMhgMIAEoBRIPCgdkdW1teTEzGA0gASgFEg8KB2R1bW15MTQYDiABKAUS" + + "DwoHZHVtbXkxNRgPIAEoBRIPCgdkdW1teTE2GBAgASgFEg8KB2R1bW15MTcY" + + "ESABKAUSDwoHZHVtbXkxOBgSIAEoBRIPCgdkdW1teTE5GBMgASgFEg8KB2R1" + + "bW15MjAYFCABKAUSDwoHZHVtbXkyMRgVIAEoBRIPCgdkdW1teTIyGBYgASgF" + + "Eg8KB2R1bW15MjMYFyABKAUSDwoHZHVtbXkyNBgYIAEoBRIPCgdkdW1teTI1" + + "GBkgASgFEg8KB2R1bW15MjYYGiABKAUSDwoHZHVtbXkyNxgbIAEoBRIPCgdk" + + "dW1teTI4GBwgASgFEg8KB2R1bW15MjkYHSABKAUSDwoHZHVtbXkzMBgeIAEo" + + "BRIPCgdkdW1teTMxGB8gASgFEg8KB2R1bW15MzIYICABKAUSCQoBYxghIAIo" + + "BTJWCgZzaW5nbGUSJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxjoByABKAsyHy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UmVxdWlyZWQy" + + "VQoFbXVsdGkSJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9u" + + "cxjpByADKAsyHy5wcm90b2J1Zl91bml0dGVzdC5UZXN0UmVxdWlyZWQimgEK" + + "E1Rlc3RSZXF1aXJlZEZvcmVpZ24SOQoQb3B0aW9uYWxfbWVzc2FnZRgBIAEo" + + "CzIfLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RSZXF1aXJlZBI5ChByZXBlYXRl" + + "ZF9tZXNzYWdlGAIgAygLMh8ucHJvdG9idWZfdW5pdHRlc3QuVGVzdFJlcXVp" + + "cmVkEg0KBWR1bW15GAMgASgFIloKEVRlc3RGb3JlaWduTmVzdGVkEkUKDmZv" + + "cmVpZ25fbmVzdGVkGAEgASgLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs" + + "bFR5cGVzLk5lc3RlZE1lc3NhZ2UiEgoQVGVzdEVtcHR5TWVzc2FnZSIqCh5U" + + "ZXN0RW1wdHlNZXNzYWdlV2l0aEV4dGVuc2lvbnMqCAgBEICAgIACIjQKGFRl" + + "c3RSZWFsbHlMYXJnZVRhZ051bWJlchIJCgFhGAEgASgFEg0KAmJiGP///38g" + + "ASgFIlUKFFRlc3RSZWN1cnNpdmVNZXNzYWdlEjIKAWEYASABKAsyJy5wcm90" + + "b2J1Zl91bml0dGVzdC5UZXN0UmVjdXJzaXZlTWVzc2FnZRIJCgFpGAIgASgF" + + "IksKFFRlc3RNdXR1YWxSZWN1cnNpb25BEjMKAmJiGAEgASgLMicucHJvdG9i" + + "dWZfdW5pdHRlc3QuVGVzdE11dHVhbFJlY3Vyc2lvbkIiYgoUVGVzdE11dHVh" + + "bFJlY3Vyc2lvbkISMgoBYRgBIAEoCzInLnByb3RvYnVmX3VuaXR0ZXN0LlRl" + + "c3RNdXR1YWxSZWN1cnNpb25BEhYKDm9wdGlvbmFsX2ludDMyGAIgASgFIrMB" + + "ChJUZXN0RHVwRmllbGROdW1iZXISCQoBYRgBIAEoBRI2CgNmb28YAiABKAoy" + + "KS5wcm90b2J1Zl91bml0dGVzdC5UZXN0RHVwRmllbGROdW1iZXIuRm9vEjYK" + + "A2JhchgDIAEoCjIpLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3REdXBGaWVsZE51" + + "bWJlci5CYXIaEAoDRm9vEgkKAWEYASABKAUaEAoDQmFyEgkKAWEYASABKAUi" + + "gAIKGFRlc3ROZXN0ZWRNZXNzYWdlSGFzQml0cxJaChdvcHRpb25hbF9uZXN0" + + "ZWRfbWVzc2FnZRgBIAEoCzI5LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3ROZXN0" + + "ZWRNZXNzYWdlSGFzQml0cy5OZXN0ZWRNZXNzYWdlGocBCg1OZXN0ZWRNZXNz" + + "YWdlEiQKHG5lc3RlZG1lc3NhZ2VfcmVwZWF0ZWRfaW50MzIYASADKAUSUAol" + + "bmVzdGVkbWVzc2FnZV9yZXBlYXRlZF9mb3JlaWdubWVzc2FnZRgCIAMoCzIh" + + "LnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25NZXNzYWdlIuUDChdUZXN0Q2Ft" + + "ZWxDYXNlRmllbGROYW1lcxIWCg5QcmltaXRpdmVGaWVsZBgBIAEoBRITCgtT" + + "dHJpbmdGaWVsZBgCIAEoCRIxCglFbnVtRmllbGQYAyABKA4yHi5wcm90b2J1" + + "Zl91bml0dGVzdC5Gb3JlaWduRW51bRI3CgxNZXNzYWdlRmllbGQYBCABKAsy" + + "IS5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWduTWVzc2FnZRIcChBTdHJpbmdQ" + + "aWVjZUZpZWxkGAUgASgJQgIIAhIVCglDb3JkRmllbGQYBiABKAlCAggBEh4K" + + "FlJlcGVhdGVkUHJpbWl0aXZlRmllbGQYByADKAUSGwoTUmVwZWF0ZWRTdHJp" + + "bmdGaWVsZBgIIAMoCRI5ChFSZXBlYXRlZEVudW1GaWVsZBgJIAMoDjIeLnBy" + + "b3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25FbnVtEj8KFFJlcGVhdGVkTWVzc2Fn" + + "ZUZpZWxkGAogAygLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbk1lc3Nh" + + "Z2USJAoYUmVwZWF0ZWRTdHJpbmdQaWVjZUZpZWxkGAsgAygJQgIIAhIdChFS" + + "ZXBlYXRlZENvcmRGaWVsZBgMIAMoCUICCAEiVQoSVGVzdEZpZWxkT3JkZXJp" + + "bmdzEhEKCW15X3N0cmluZxgLIAEoCRIOCgZteV9pbnQYASABKAMSEAoIbXlf" + + "ZmxvYXQYZSABKAIqBAgCEAsqBAgMEGUikAIKGFRlc3RFeHRyZW1lRGVmYXVs" + + "dFZhbHVlcxI/Cg1lc2NhcGVkX2J5dGVzGAEgASgMOihcMDAwXDAwMVwwMDdc" + + "MDEwXDAxNFxuXHJcdFwwMTNcXFwnXCJcMzc2EiAKDGxhcmdlX3VpbnQzMhgC" + + "IAEoDToKNDI5NDk2NzI5NRIqCgxsYXJnZV91aW50NjQYAyABKAQ6FDE4NDQ2" + + "NzQ0MDczNzA5NTUxNjE1EiAKC3NtYWxsX2ludDMyGAQgASgFOgstMjE0NzQ4" + + "MzY0NxIpCgtzbWFsbF9pbnQ2NBgFIAEoAzoULTkyMjMzNzIwMzY4NTQ3NzU4" + + "MDcSGAoLdXRmOF9zdHJpbmcYBiABKAk6A+GItCIMCgpGb29SZXF1ZXN0Ig0K" + + "C0Zvb1Jlc3BvbnNlIgwKCkJhclJlcXVlc3QiDQoLQmFyUmVzcG9uc2UqQAoL" + + "Rm9yZWlnbkVudW0SDwoLRk9SRUlHTl9GT08QBBIPCgtGT1JFSUdOX0JBUhAF" + + "Eg8KC0ZPUkVJR05fQkFaEAYqRwoUVGVzdEVudW1XaXRoRHVwVmFsdWUSCAoE" + + "Rk9PMRABEggKBEJBUjEQAhIHCgNCQVoQAxIICgRGT08yEAESCAoEQkFSMhAC" + + "KokBCg5UZXN0U3BhcnNlRW51bRIMCghTUEFSU0VfQRB7Eg4KCFNQQVJTRV9C" + + "EKbnAxIPCghTUEFSU0VfQxCysYAGEhUKCFNQQVJTRV9EEPH//////////wES" + + "FQoIU1BBUlNFX0UQtN78////////ARIMCghTUEFSU0VfRhAAEgwKCFNQQVJT" + + "RV9HEAIymQEKC1Rlc3RTZXJ2aWNlEkQKA0ZvbxIdLnByb3RvYnVmX3VuaXR0" + + "ZXN0LkZvb1JlcXVlc3QaHi5wcm90b2J1Zl91bml0dGVzdC5Gb29SZXNwb25z" + + "ZRJECgNCYXISHS5wcm90b2J1Zl91bml0dGVzdC5CYXJSZXF1ZXN0Gh4ucHJv" + + "dG9idWZfdW5pdHRlc3QuQmFyUmVzcG9uc2U6RgoYb3B0aW9uYWxfaW50MzJf" + + "ZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lv" + + "bnMYASABKAU6RgoYb3B0aW9uYWxfaW50NjRfZXh0ZW5zaW9uEiQucHJvdG9i" + + "dWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYAiABKAM6RwoZb3B0aW9u" + + "YWxfdWludDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB" + + "bGxFeHRlbnNpb25zGAMgASgNOkcKGW9wdGlvbmFsX3VpbnQ2NF9leHRlbnNp" + + "b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgEIAEo" + + "BDpHChlvcHRpb25hbF9zaW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" + + "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYBSABKBE6RwoZb3B0aW9uYWxfc2lu" + + "dDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl" + + "bnNpb25zGAYgASgSOkgKGm9wdGlvbmFsX2ZpeGVkMzJfZXh0ZW5zaW9uEiQu" + + "cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYByABKAc6SAoa" + + "b3B0aW9uYWxfZml4ZWQ2NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVz" + + "dC5UZXN0QWxsRXh0ZW5zaW9ucxgIIAEoBjpJChtvcHRpb25hbF9zZml4ZWQz" + + "Ml9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxgJIAEoDzpJChtvcHRpb25hbF9zZml4ZWQ2NF9leHRlbnNpb24SJC5w" + + "cm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgKIAEoEDpGChhv" + + "cHRpb25hbF9mbG9hdF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U" + + "ZXN0QWxsRXh0ZW5zaW9ucxgLIAEoAjpHChlvcHRpb25hbF9kb3VibGVfZXh0" + + "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" + + "DCABKAE6RQoXb3B0aW9uYWxfYm9vbF9leHRlbnNpb24SJC5wcm90b2J1Zl91" + + "bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgNIAEoCDpHChlvcHRpb25hbF9z" + + "dHJpbmdfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4" + + "dGVuc2lvbnMYDiABKAk6RgoYb3B0aW9uYWxfYnl0ZXNfZXh0ZW5zaW9uEiQu" + + "cHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYDyABKAw6cQoX" + + "b3B0aW9uYWxncm91cF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U" + + "ZXN0QWxsRXh0ZW5zaW9ucxgQIAEoCjIqLnByb3RvYnVmX3VuaXR0ZXN0Lk9w" + + "dGlvbmFsR3JvdXBfZXh0ZW5zaW9uOn4KIW9wdGlvbmFsX25lc3RlZF9tZXNz" + + "YWdlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRl" + + "bnNpb25zGBIgASgLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVz" + + "Lk5lc3RlZE1lc3NhZ2U6cwoib3B0aW9uYWxfZm9yZWlnbl9tZXNzYWdlX2V4" + + "dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25z" + + "GBMgASgLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbk1lc3NhZ2U6eAoh" + + "b3B0aW9uYWxfaW1wb3J0X21lc3NhZ2VfZXh0ZW5zaW9uEiQucHJvdG9idWZf" + + "dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYFCABKAsyJy5wcm90b2J1Zl91" + + "bml0dGVzdF9pbXBvcnQuSW1wb3J0TWVzc2FnZTp4Ch5vcHRpb25hbF9uZXN0" + + "ZWRfZW51bV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxs" + + "RXh0ZW5zaW9ucxgVIAEoDjIqLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxU" + + "eXBlcy5OZXN0ZWRFbnVtOm0KH29wdGlvbmFsX2ZvcmVpZ25fZW51bV9leHRl" + + "bnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgW" + + "IAEoDjIeLnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25FbnVtOnIKHm9wdGlv" + + "bmFsX2ltcG9ydF9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0" + + "LlRlc3RBbGxFeHRlbnNpb25zGBcgASgOMiQucHJvdG9idWZfdW5pdHRlc3Rf" + + "aW1wb3J0LkltcG9ydEVudW06UQofb3B0aW9uYWxfc3RyaW5nX3BpZWNlX2V4" + + "dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25z" + + "GBggASgJQgIIAjpJChdvcHRpb25hbF9jb3JkX2V4dGVuc2lvbhIkLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGBkgASgJQgIIATpGChhy" + + "ZXBlYXRlZF9pbnQzMl9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5U" + + "ZXN0QWxsRXh0ZW5zaW9ucxgfIAMoBTpGChhyZXBlYXRlZF9pbnQ2NF9leHRl" + + "bnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgg" + + "IAMoAzpHChlyZXBlYXRlZF91aW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZf" + + "dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYISADKA06RwoZcmVwZWF0ZWRf" + + "dWludDY0X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxF" + + "eHRlbnNpb25zGCIgAygEOkcKGXJlcGVhdGVkX3NpbnQzMl9leHRlbnNpb24S" + + "JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgjIAMoETpH" + + "ChlyZXBlYXRlZF9zaW50NjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbEV4dGVuc2lvbnMYJCADKBI6SAoacmVwZWF0ZWRfZml4ZWQz" + + "Ml9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxglIAMoBzpIChpyZXBlYXRlZF9maXhlZDY0X2V4dGVuc2lvbhIkLnBy" + + "b3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCYgAygGOkkKG3Jl" + + "cGVhdGVkX3NmaXhlZDMyX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0" + + "LlRlc3RBbGxFeHRlbnNpb25zGCcgAygPOkkKG3JlcGVhdGVkX3NmaXhlZDY0" + + "X2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNp" + + "b25zGCggAygQOkYKGHJlcGVhdGVkX2Zsb2F0X2V4dGVuc2lvbhIkLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCkgAygCOkcKGXJlcGVh" + + "dGVkX2RvdWJsZV9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0" + + "QWxsRXh0ZW5zaW9ucxgqIAMoATpFChdyZXBlYXRlZF9ib29sX2V4dGVuc2lv" + + "bhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGCsgAygI" + + "OkcKGXJlcGVhdGVkX3N0cmluZ19leHRlbnNpb24SJC5wcm90b2J1Zl91bml0" + + "dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgsIAMoCTpGChhyZXBlYXRlZF9ieXRl" + + "c19leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxgtIAMoDDpxChdyZXBlYXRlZGdyb3VwX2V4dGVuc2lvbhIkLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGC4gAygKMioucHJvdG9i" + + "dWZfdW5pdHRlc3QuUmVwZWF0ZWRHcm91cF9leHRlbnNpb246fgohcmVwZWF0" + + "ZWRfbmVzdGVkX21lc3NhZ2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbEV4dGVuc2lvbnMYMCADKAsyLS5wcm90b2J1Zl91bml0dGVz" + + "dC5UZXN0QWxsVHlwZXMuTmVzdGVkTWVzc2FnZTpzCiJyZXBlYXRlZF9mb3Jl" + + "aWduX21lc3NhZ2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz" + + "dEFsbEV4dGVuc2lvbnMYMSADKAsyIS5wcm90b2J1Zl91bml0dGVzdC5Gb3Jl" + + "aWduTWVzc2FnZTp4CiFyZXBlYXRlZF9pbXBvcnRfbWVzc2FnZV9leHRlbnNp" + + "b24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxgyIAMo" + + "CzInLnByb3RvYnVmX3VuaXR0ZXN0X2ltcG9ydC5JbXBvcnRNZXNzYWdlOngK" + + "HnJlcGVhdGVkX25lc3RlZF9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3Vu" + + "aXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGDMgAygOMioucHJvdG9idWZfdW5p" + + "dHRlc3QuVGVzdEFsbFR5cGVzLk5lc3RlZEVudW06bQofcmVwZWF0ZWRfZm9y" + + "ZWlnbl9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB" + + "bGxFeHRlbnNpb25zGDQgAygOMh4ucHJvdG9idWZfdW5pdHRlc3QuRm9yZWln" + + "bkVudW06cgoecmVwZWF0ZWRfaW1wb3J0X2VudW1fZXh0ZW5zaW9uEiQucHJv" + + "dG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYNSADKA4yJC5wcm90" + + "b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bTpRCh9yZXBlYXRlZF9z" + + "dHJpbmdfcGllY2VfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz" + + "dEFsbEV4dGVuc2lvbnMYNiADKAlCAggCOkkKF3JlcGVhdGVkX2NvcmRfZXh0" + + "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" + + "NyADKAlCAggBOkkKF2RlZmF1bHRfaW50MzJfZXh0ZW5zaW9uEiQucHJvdG9i" + + "dWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYPSABKAU6AjQxOkkKF2Rl" + + "ZmF1bHRfaW50NjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVz" + + "dEFsbEV4dGVuc2lvbnMYPiABKAM6AjQyOkoKGGRlZmF1bHRfdWludDMyX2V4" + + "dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25z" + + "GD8gASgNOgI0MzpKChhkZWZhdWx0X3VpbnQ2NF9leHRlbnNpb24SJC5wcm90" + + "b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhAIAEoBDoCNDQ6SwoY" + + "ZGVmYXVsdF9zaW50MzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3Qu" + + "VGVzdEFsbEV4dGVuc2lvbnMYQSABKBE6Ay00NTpKChhkZWZhdWx0X3NpbnQ2" + + "NF9leHRlbnNpb24SJC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5z" + + "aW9ucxhCIAEoEjoCNDY6SwoZZGVmYXVsdF9maXhlZDMyX2V4dGVuc2lvbhIk" + + "LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGEMgASgHOgI0" + + "NzpLChlkZWZhdWx0X2ZpeGVkNjRfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5p" + + "dHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYRCABKAY6AjQ4OkwKGmRlZmF1bHRf" + + "c2ZpeGVkMzJfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFs" + + "bEV4dGVuc2lvbnMYRSABKA86AjQ5Ok0KGmRlZmF1bHRfc2ZpeGVkNjRfZXh0" + + "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" + + "RiABKBA6Ay01MDpLChdkZWZhdWx0X2Zsb2F0X2V4dGVuc2lvbhIkLnByb3Rv" + + "YnVmX3VuaXR0ZXN0LlRlc3RBbGxFeHRlbnNpb25zGEcgASgCOgQ1MS41Ok0K" + + "GGRlZmF1bHRfZG91YmxlX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0" + + "LlRlc3RBbGxFeHRlbnNpb25zGEggASgBOgU1MjAwMDpKChZkZWZhdWx0X2Jv" + + "b2xfZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVu" + + "c2lvbnMYSSABKAg6BHRydWU6TQoYZGVmYXVsdF9zdHJpbmdfZXh0ZW5zaW9u" + + "EiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYSiABKAk6" + + "BWhlbGxvOkwKF2RlZmF1bHRfYnl0ZXNfZXh0ZW5zaW9uEiQucHJvdG9idWZf" + + "dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYSyABKAw6BXdvcmxkOnwKHWRl" + + "ZmF1bHRfbmVzdGVkX2VudW1fZXh0ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRl" + + "c3QuVGVzdEFsbEV4dGVuc2lvbnMYUSABKA4yKi5wcm90b2J1Zl91bml0dGVz" + + "dC5UZXN0QWxsVHlwZXMuTmVzdGVkRW51bToDQkFSOnkKHmRlZmF1bHRfZm9y" + + "ZWlnbl9lbnVtX2V4dGVuc2lvbhIkLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RB" + + "bGxFeHRlbnNpb25zGFIgASgOMh4ucHJvdG9idWZfdW5pdHRlc3QuRm9yZWln" + + "bkVudW06C0ZPUkVJR05fQkFSOn0KHWRlZmF1bHRfaW1wb3J0X2VudW1fZXh0" + + "ZW5zaW9uEiQucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMY" + + "UyABKA4yJC5wcm90b2J1Zl91bml0dGVzdF9pbXBvcnQuSW1wb3J0RW51bToK" + + "SU1QT1JUX0JBUjpVCh5kZWZhdWx0X3N0cmluZ19waWVjZV9leHRlbnNpb24S" + + "JC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsRXh0ZW5zaW9ucxhUIAEoCToD" + + "YWJjQgIIAjpNChZkZWZhdWx0X2NvcmRfZXh0ZW5zaW9uEiQucHJvdG9idWZf" + + "dW5pdHRlc3QuVGVzdEFsbEV4dGVuc2lvbnMYVSABKAk6AzEyM0ICCAE6QgoT" + + "bXlfZXh0ZW5zaW9uX3N0cmluZxIlLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RG" + + "aWVsZE9yZGVyaW5ncxgyIAEoCTo/ChBteV9leHRlbnNpb25faW50EiUucHJv" + + "dG9idWZfdW5pdHRlc3QuVGVzdEZpZWxkT3JkZXJpbmdzGAUgASgFQktCDVVu" + + "aXR0ZXN0UHJvdG9IAYLiCSFHb29nbGUuUHJvdG9jb2xCdWZmZXJzLlRlc3RQ" + + "cm90b3OK4gkRVW5pdFRlc3RQcm90b0ZpbGU="), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + global::Google.ProtocolBuffers.TestProtos.UnitTestImportProtoFile.Descriptor, + }); + #endregion + + #region Extensions + public static readonly pb::GeneratedExtensionBase<int> OptionalInt32Extension = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[0]); + public static readonly pb::GeneratedExtensionBase<long> OptionalInt64Extension = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[1]); + public static readonly pb::GeneratedExtensionBase<uint> OptionalUint32Extension = + pb::GeneratedSingleExtension<uint>.CreateInstance(Descriptor.Extensions[2]); + public static readonly pb::GeneratedExtensionBase<ulong> OptionalUint64Extension = + pb::GeneratedSingleExtension<ulong>.CreateInstance(Descriptor.Extensions[3]); + public static readonly pb::GeneratedExtensionBase<int> OptionalSint32Extension = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[4]); + public static readonly pb::GeneratedExtensionBase<long> OptionalSint64Extension = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[5]); + public static readonly pb::GeneratedExtensionBase<uint> OptionalFixed32Extension = + pb::GeneratedSingleExtension<uint>.CreateInstance(Descriptor.Extensions[6]); + public static readonly pb::GeneratedExtensionBase<ulong> OptionalFixed64Extension = + pb::GeneratedSingleExtension<ulong>.CreateInstance(Descriptor.Extensions[7]); + public static readonly pb::GeneratedExtensionBase<int> OptionalSfixed32Extension = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[8]); + public static readonly pb::GeneratedExtensionBase<long> OptionalSfixed64Extension = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[9]); + public static readonly pb::GeneratedExtensionBase<float> OptionalFloatExtension = + pb::GeneratedSingleExtension<float>.CreateInstance(Descriptor.Extensions[10]); + public static readonly pb::GeneratedExtensionBase<double> OptionalDoubleExtension = + pb::GeneratedSingleExtension<double>.CreateInstance(Descriptor.Extensions[11]); + public static readonly pb::GeneratedExtensionBase<bool> OptionalBoolExtension = + pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[12]); + public static readonly pb::GeneratedExtensionBase<string> OptionalStringExtension = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[13]); + public static readonly pb::GeneratedExtensionBase<pb::ByteString> OptionalBytesExtension = + pb::GeneratedSingleExtension<pb::ByteString>.CreateInstance(Descriptor.Extensions[14]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.OptionalGroup_extension> OptionalGroupExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.OptionalGroup_extension>.CreateInstance(Descriptor.Extensions[15]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage> OptionalNestedMessageExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage>.CreateInstance(Descriptor.Extensions[16]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> OptionalForeignMessageExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ForeignMessage>.CreateInstance(Descriptor.Extensions[17]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ImportMessage> OptionalImportMessageExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ImportMessage>.CreateInstance(Descriptor.Extensions[18]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum> OptionalNestedEnumExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum>.CreateInstance(Descriptor.Extensions[19]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> OptionalForeignEnumExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ForeignEnum>.CreateInstance(Descriptor.Extensions[20]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ImportEnum> OptionalImportEnumExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ImportEnum>.CreateInstance(Descriptor.Extensions[21]); + public static readonly pb::GeneratedExtensionBase<string> OptionalStringPieceExtension = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[22]); + public static readonly pb::GeneratedExtensionBase<string> OptionalCordExtension = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[23]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<int>> RepeatedInt32Extension = + pb::GeneratedRepeatExtension<int>.CreateInstance(Descriptor.Extensions[24]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<long>> RepeatedInt64Extension = + pb::GeneratedRepeatExtension<long>.CreateInstance(Descriptor.Extensions[25]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<uint>> RepeatedUint32Extension = + pb::GeneratedRepeatExtension<uint>.CreateInstance(Descriptor.Extensions[26]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<ulong>> RepeatedUint64Extension = + pb::GeneratedRepeatExtension<ulong>.CreateInstance(Descriptor.Extensions[27]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<int>> RepeatedSint32Extension = + pb::GeneratedRepeatExtension<int>.CreateInstance(Descriptor.Extensions[28]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<long>> RepeatedSint64Extension = + pb::GeneratedRepeatExtension<long>.CreateInstance(Descriptor.Extensions[29]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<uint>> RepeatedFixed32Extension = + pb::GeneratedRepeatExtension<uint>.CreateInstance(Descriptor.Extensions[30]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<ulong>> RepeatedFixed64Extension = + pb::GeneratedRepeatExtension<ulong>.CreateInstance(Descriptor.Extensions[31]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<int>> RepeatedSfixed32Extension = + pb::GeneratedRepeatExtension<int>.CreateInstance(Descriptor.Extensions[32]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<long>> RepeatedSfixed64Extension = + pb::GeneratedRepeatExtension<long>.CreateInstance(Descriptor.Extensions[33]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<float>> RepeatedFloatExtension = + pb::GeneratedRepeatExtension<float>.CreateInstance(Descriptor.Extensions[34]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<double>> RepeatedDoubleExtension = + pb::GeneratedRepeatExtension<double>.CreateInstance(Descriptor.Extensions[35]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<bool>> RepeatedBoolExtension = + pb::GeneratedRepeatExtension<bool>.CreateInstance(Descriptor.Extensions[36]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<string>> RepeatedStringExtension = + pb::GeneratedRepeatExtension<string>.CreateInstance(Descriptor.Extensions[37]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<pb::ByteString>> RepeatedBytesExtension = + pb::GeneratedRepeatExtension<pb::ByteString>.CreateInstance(Descriptor.Extensions[38]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<global::Google.ProtocolBuffers.TestProtos.RepeatedGroup_extension>> RepeatedGroupExtension = + pb::GeneratedRepeatExtension<global::Google.ProtocolBuffers.TestProtos.RepeatedGroup_extension>.CreateInstance(Descriptor.Extensions[39]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage>> RepeatedNestedMessageExtension = + pb::GeneratedRepeatExtension<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage>.CreateInstance(Descriptor.Extensions[40]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage>> RepeatedForeignMessageExtension = + pb::GeneratedRepeatExtension<global::Google.ProtocolBuffers.TestProtos.ForeignMessage>.CreateInstance(Descriptor.Extensions[41]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<global::Google.ProtocolBuffers.TestProtos.ImportMessage>> RepeatedImportMessageExtension = + pb::GeneratedRepeatExtension<global::Google.ProtocolBuffers.TestProtos.ImportMessage>.CreateInstance(Descriptor.Extensions[42]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum>> RepeatedNestedEnumExtension = + pb::GeneratedRepeatExtension<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum>.CreateInstance(Descriptor.Extensions[43]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignEnum>> RepeatedForeignEnumExtension = + pb::GeneratedRepeatExtension<global::Google.ProtocolBuffers.TestProtos.ForeignEnum>.CreateInstance(Descriptor.Extensions[44]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<global::Google.ProtocolBuffers.TestProtos.ImportEnum>> RepeatedImportEnumExtension = + pb::GeneratedRepeatExtension<global::Google.ProtocolBuffers.TestProtos.ImportEnum>.CreateInstance(Descriptor.Extensions[45]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<string>> RepeatedStringPieceExtension = + pb::GeneratedRepeatExtension<string>.CreateInstance(Descriptor.Extensions[46]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<string>> RepeatedCordExtension = + pb::GeneratedRepeatExtension<string>.CreateInstance(Descriptor.Extensions[47]); + public static readonly pb::GeneratedExtensionBase<int> DefaultInt32Extension = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[48]); + public static readonly pb::GeneratedExtensionBase<long> DefaultInt64Extension = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[49]); + public static readonly pb::GeneratedExtensionBase<uint> DefaultUint32Extension = + pb::GeneratedSingleExtension<uint>.CreateInstance(Descriptor.Extensions[50]); + public static readonly pb::GeneratedExtensionBase<ulong> DefaultUint64Extension = + pb::GeneratedSingleExtension<ulong>.CreateInstance(Descriptor.Extensions[51]); + public static readonly pb::GeneratedExtensionBase<int> DefaultSint32Extension = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[52]); + public static readonly pb::GeneratedExtensionBase<long> DefaultSint64Extension = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[53]); + public static readonly pb::GeneratedExtensionBase<uint> DefaultFixed32Extension = + pb::GeneratedSingleExtension<uint>.CreateInstance(Descriptor.Extensions[54]); + public static readonly pb::GeneratedExtensionBase<ulong> DefaultFixed64Extension = + pb::GeneratedSingleExtension<ulong>.CreateInstance(Descriptor.Extensions[55]); + public static readonly pb::GeneratedExtensionBase<int> DefaultSfixed32Extension = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[56]); + public static readonly pb::GeneratedExtensionBase<long> DefaultSfixed64Extension = + pb::GeneratedSingleExtension<long>.CreateInstance(Descriptor.Extensions[57]); + public static readonly pb::GeneratedExtensionBase<float> DefaultFloatExtension = + pb::GeneratedSingleExtension<float>.CreateInstance(Descriptor.Extensions[58]); + public static readonly pb::GeneratedExtensionBase<double> DefaultDoubleExtension = + pb::GeneratedSingleExtension<double>.CreateInstance(Descriptor.Extensions[59]); + public static readonly pb::GeneratedExtensionBase<bool> DefaultBoolExtension = + pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[60]); + public static readonly pb::GeneratedExtensionBase<string> DefaultStringExtension = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[61]); + public static readonly pb::GeneratedExtensionBase<pb::ByteString> DefaultBytesExtension = + pb::GeneratedSingleExtension<pb::ByteString>.CreateInstance(Descriptor.Extensions[62]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum> DefaultNestedEnumExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum>.CreateInstance(Descriptor.Extensions[63]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> DefaultForeignEnumExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ForeignEnum>.CreateInstance(Descriptor.Extensions[64]); + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ImportEnum> DefaultImportEnumExtension = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ImportEnum>.CreateInstance(Descriptor.Extensions[65]); + public static readonly pb::GeneratedExtensionBase<string> DefaultStringPieceExtension = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[66]); + public static readonly pb::GeneratedExtensionBase<string> DefaultCordExtension = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[67]); + public static readonly pb::GeneratedExtensionBase<string> MyExtensionString = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[68]); + public static readonly pb::GeneratedExtensionBase<int> MyExtensionInt = + pb::GeneratedSingleExtension<int>.CreateInstance(Descriptor.Extensions[69]); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllTypes__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Builder> internal__static_protobuf_unittest_TestAllTypes__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Builder>(internal__static_protobuf_unittest_TestAllTypes__Descriptor, + new string[] { "OptionalInt32", "OptionalInt64", "OptionalUint32", "OptionalUint64", "OptionalSint32", "OptionalSint64", "OptionalFixed32", "OptionalFixed64", "OptionalSfixed32", "OptionalSfixed64", "OptionalFloat", "OptionalDouble", "OptionalBool", "OptionalString", "OptionalBytes", "OptionalGroup", "OptionalNestedMessage", "OptionalForeignMessage", "OptionalImportMessage", "OptionalNestedEnum", "OptionalForeignEnum", "OptionalImportEnum", "OptionalStringPiece", "OptionalCord", "RepeatedInt32", "RepeatedInt64", "RepeatedUint32", "RepeatedUint64", "RepeatedSint32", "RepeatedSint64", "RepeatedFixed32", "RepeatedFixed64", "RepeatedSfixed32", "RepeatedSfixed64", "RepeatedFloat", "RepeatedDouble", "RepeatedBool", "RepeatedString", "RepeatedBytes", "RepeatedGroup", "RepeatedNestedMessage", "RepeatedForeignMessage", "RepeatedImportMessage", "RepeatedNestedEnum", "RepeatedForeignEnum", "RepeatedImportEnum", "RepeatedStringPiece", "RepeatedCord", "DefaultInt32", "DefaultInt64", "DefaultUint32", "DefaultUint64", "DefaultSint32", "DefaultSint64", "DefaultFixed32", "DefaultFixed64", "DefaultSfixed32", "DefaultSfixed64", "DefaultFloat", "DefaultDouble", "DefaultBool", "DefaultString", "DefaultBytes", "DefaultNestedEnum", "DefaultForeignEnum", "DefaultImportEnum", "DefaultStringPiece", "DefaultCord", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllTypes_NestedMessage__Descriptor + = internal__static_protobuf_unittest_TestAllTypes__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder> internal__static_protobuf_unittest_TestAllTypes_NestedMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder>(internal__static_protobuf_unittest_TestAllTypes_NestedMessage__Descriptor, + new string[] { "Bb", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__Descriptor + = internal__static_protobuf_unittest_TestAllTypes__Descriptor.NestedTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.Builder> internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.Builder>(internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__Descriptor + = internal__static_protobuf_unittest_TestAllTypes__Descriptor.NestedTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.Builder> internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.Builder>(internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_ForeignMessage__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ForeignMessage, global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder> internal__static_protobuf_unittest_ForeignMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ForeignMessage, global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder>(internal__static_protobuf_unittest_ForeignMessage__Descriptor, + new string[] { "C", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestAllExtensions__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllExtensions, global::Google.ProtocolBuffers.TestProtos.TestAllExtensions.Builder> internal__static_protobuf_unittest_TestAllExtensions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestAllExtensions, global::Google.ProtocolBuffers.TestProtos.TestAllExtensions.Builder>(internal__static_protobuf_unittest_TestAllExtensions__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_OptionalGroup_extension__Descriptor + = Descriptor.MessageTypes[3]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.OptionalGroup_extension, global::Google.ProtocolBuffers.TestProtos.OptionalGroup_extension.Builder> internal__static_protobuf_unittest_OptionalGroup_extension__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.OptionalGroup_extension, global::Google.ProtocolBuffers.TestProtos.OptionalGroup_extension.Builder>(internal__static_protobuf_unittest_OptionalGroup_extension__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_RepeatedGroup_extension__Descriptor + = Descriptor.MessageTypes[4]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.RepeatedGroup_extension, global::Google.ProtocolBuffers.TestProtos.RepeatedGroup_extension.Builder> internal__static_protobuf_unittest_RepeatedGroup_extension__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.RepeatedGroup_extension, global::Google.ProtocolBuffers.TestProtos.RepeatedGroup_extension.Builder>(internal__static_protobuf_unittest_RepeatedGroup_extension__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestRequired__Descriptor + = Descriptor.MessageTypes[5]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRequired, global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder> internal__static_protobuf_unittest_TestRequired__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRequired, global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder>(internal__static_protobuf_unittest_TestRequired__Descriptor, + new string[] { "A", "Dummy2", "B", "Dummy4", "Dummy5", "Dummy6", "Dummy7", "Dummy8", "Dummy9", "Dummy10", "Dummy11", "Dummy12", "Dummy13", "Dummy14", "Dummy15", "Dummy16", "Dummy17", "Dummy18", "Dummy19", "Dummy20", "Dummy21", "Dummy22", "Dummy23", "Dummy24", "Dummy25", "Dummy26", "Dummy27", "Dummy28", "Dummy29", "Dummy30", "Dummy31", "Dummy32", "C", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestRequiredForeign__Descriptor + = Descriptor.MessageTypes[6]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRequiredForeign, global::Google.ProtocolBuffers.TestProtos.TestRequiredForeign.Builder> internal__static_protobuf_unittest_TestRequiredForeign__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRequiredForeign, global::Google.ProtocolBuffers.TestProtos.TestRequiredForeign.Builder>(internal__static_protobuf_unittest_TestRequiredForeign__Descriptor, + new string[] { "OptionalMessage", "RepeatedMessage", "Dummy", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestForeignNested__Descriptor + = Descriptor.MessageTypes[7]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestForeignNested, global::Google.ProtocolBuffers.TestProtos.TestForeignNested.Builder> internal__static_protobuf_unittest_TestForeignNested__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestForeignNested, global::Google.ProtocolBuffers.TestProtos.TestForeignNested.Builder>(internal__static_protobuf_unittest_TestForeignNested__Descriptor, + new string[] { "ForeignNested", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestEmptyMessage__Descriptor + = Descriptor.MessageTypes[8]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestEmptyMessage, global::Google.ProtocolBuffers.TestProtos.TestEmptyMessage.Builder> internal__static_protobuf_unittest_TestEmptyMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestEmptyMessage, global::Google.ProtocolBuffers.TestProtos.TestEmptyMessage.Builder>(internal__static_protobuf_unittest_TestEmptyMessage__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__Descriptor + = Descriptor.MessageTypes[9]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestEmptyMessageWithExtensions, global::Google.ProtocolBuffers.TestProtos.TestEmptyMessageWithExtensions.Builder> internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestEmptyMessageWithExtensions, global::Google.ProtocolBuffers.TestProtos.TestEmptyMessageWithExtensions.Builder>(internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestReallyLargeTagNumber__Descriptor + = Descriptor.MessageTypes[10]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestReallyLargeTagNumber, global::Google.ProtocolBuffers.TestProtos.TestReallyLargeTagNumber.Builder> internal__static_protobuf_unittest_TestReallyLargeTagNumber__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestReallyLargeTagNumber, global::Google.ProtocolBuffers.TestProtos.TestReallyLargeTagNumber.Builder>(internal__static_protobuf_unittest_TestReallyLargeTagNumber__Descriptor, + new string[] { "A", "Bb", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestRecursiveMessage__Descriptor + = Descriptor.MessageTypes[11]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage, global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.Builder> internal__static_protobuf_unittest_TestRecursiveMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage, global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.Builder>(internal__static_protobuf_unittest_TestRecursiveMessage__Descriptor, + new string[] { "A", "I", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMutualRecursionA__Descriptor + = Descriptor.MessageTypes[12]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA, global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.Builder> internal__static_protobuf_unittest_TestMutualRecursionA__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA, global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.Builder>(internal__static_protobuf_unittest_TestMutualRecursionA__Descriptor, + new string[] { "Bb", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestMutualRecursionB__Descriptor + = Descriptor.MessageTypes[13]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB, global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.Builder> internal__static_protobuf_unittest_TestMutualRecursionB__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB, global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.Builder>(internal__static_protobuf_unittest_TestMutualRecursionB__Descriptor, + new string[] { "A", "OptionalInt32", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor + = Descriptor.MessageTypes[14]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber, global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Builder> internal__static_protobuf_unittest_TestDupFieldNumber__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber, global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Builder>(internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor, + new string[] { "A", "Foo", "Bar", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestDupFieldNumber_Foo__Descriptor + = internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo, global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.Builder> internal__static_protobuf_unittest_TestDupFieldNumber_Foo__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo, global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.Builder>(internal__static_protobuf_unittest_TestDupFieldNumber_Foo__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestDupFieldNumber_Bar__Descriptor + = internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor.NestedTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar, global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.Builder> internal__static_protobuf_unittest_TestDupFieldNumber_Bar__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar, global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.Builder>(internal__static_protobuf_unittest_TestDupFieldNumber_Bar__Descriptor, + new string[] { "A", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestNestedMessageHasBits__Descriptor + = Descriptor.MessageTypes[15]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits, global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Builder> internal__static_protobuf_unittest_TestNestedMessageHasBits__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits, global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Builder>(internal__static_protobuf_unittest_TestNestedMessageHasBits__Descriptor, + new string[] { "OptionalNestedMessage", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__Descriptor + = internal__static_protobuf_unittest_TestNestedMessageHasBits__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage, global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.Builder> internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage, global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.Builder>(internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__Descriptor, + new string[] { "NestedmessageRepeatedInt32", "NestedmessageRepeatedForeignmessage", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestCamelCaseFieldNames__Descriptor + = Descriptor.MessageTypes[16]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestCamelCaseFieldNames, global::Google.ProtocolBuffers.TestProtos.TestCamelCaseFieldNames.Builder> internal__static_protobuf_unittest_TestCamelCaseFieldNames__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestCamelCaseFieldNames, global::Google.ProtocolBuffers.TestProtos.TestCamelCaseFieldNames.Builder>(internal__static_protobuf_unittest_TestCamelCaseFieldNames__Descriptor, + new string[] { "PrimitiveField", "StringField", "EnumField", "MessageField", "StringPieceField", "CordField", "RepeatedPrimitiveField", "RepeatedStringField", "RepeatedEnumField", "RepeatedMessageField", "RepeatedStringPieceField", "RepeatedCordField", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestFieldOrderings__Descriptor + = Descriptor.MessageTypes[17]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestFieldOrderings, global::Google.ProtocolBuffers.TestProtos.TestFieldOrderings.Builder> internal__static_protobuf_unittest_TestFieldOrderings__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestFieldOrderings, global::Google.ProtocolBuffers.TestProtos.TestFieldOrderings.Builder>(internal__static_protobuf_unittest_TestFieldOrderings__Descriptor, + new string[] { "MyString", "MyInt", "MyFloat", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_TestExtremeDefaultValues__Descriptor + = Descriptor.MessageTypes[18]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues, global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Builder> internal__static_protobuf_unittest_TestExtremeDefaultValues__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues, global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Builder>(internal__static_protobuf_unittest_TestExtremeDefaultValues__Descriptor, + new string[] { "EscapedBytes", "LargeUint32", "LargeUint64", "SmallInt32", "SmallInt64", "Utf8String", }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_FooRequest__Descriptor + = Descriptor.MessageTypes[19]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.FooRequest, global::Google.ProtocolBuffers.TestProtos.FooRequest.Builder> internal__static_protobuf_unittest_FooRequest__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.FooRequest, global::Google.ProtocolBuffers.TestProtos.FooRequest.Builder>(internal__static_protobuf_unittest_FooRequest__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_FooResponse__Descriptor + = Descriptor.MessageTypes[20]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.FooResponse, global::Google.ProtocolBuffers.TestProtos.FooResponse.Builder> internal__static_protobuf_unittest_FooResponse__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.FooResponse, global::Google.ProtocolBuffers.TestProtos.FooResponse.Builder>(internal__static_protobuf_unittest_FooResponse__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_BarRequest__Descriptor + = Descriptor.MessageTypes[21]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.BarRequest, global::Google.ProtocolBuffers.TestProtos.BarRequest.Builder> internal__static_protobuf_unittest_BarRequest__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.BarRequest, global::Google.ProtocolBuffers.TestProtos.BarRequest.Builder>(internal__static_protobuf_unittest_BarRequest__Descriptor, + new string[] { }); + internal static readonly pbd::MessageDescriptor internal__static_protobuf_unittest_BarResponse__Descriptor + = Descriptor.MessageTypes[22]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.BarResponse, global::Google.ProtocolBuffers.TestProtos.BarResponse.Builder> internal__static_protobuf_unittest_BarResponse__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.BarResponse, global::Google.ProtocolBuffers.TestProtos.BarResponse.Builder>(internal__static_protobuf_unittest_BarResponse__Descriptor, + new string[] { }); + #endregion + } + #region Enums + public enum ForeignEnum { + FOREIGN_FOO = 4, + FOREIGN_BAR = 5, + FOREIGN_BAZ = 6, + } + + public enum TestEnumWithDupValue { + FOO1 = 1, + BAR1 = 2, + BAZ = 3, + FOO2 = 1, + BAR2 = 2, + } + + public enum TestSparseEnum { + SPARSE_A = 123, + SPARSE_B = 62374, + SPARSE_C = 12589234, + SPARSE_D = -15, + SPARSE_E = -53452, + SPARSE_F = 0, + SPARSE_G = 2, + } + + #endregion + + #region Messages + public sealed partial class TestAllTypes : pb::GeneratedMessage<TestAllTypes, TestAllTypes.Builder> { + private static readonly TestAllTypes defaultInstance = new Builder().BuildPartial(); + public static TestAllTypes DefaultInstance { + get { return defaultInstance; } + } + + public override TestAllTypes DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestAllTypes ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestAllTypes, TestAllTypes.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum NestedEnum { + FOO = 1, + BAR = 2, + BAZ = 3, + } + + public sealed partial class NestedMessage : pb::GeneratedMessage<NestedMessage, NestedMessage.Builder> { + private static readonly NestedMessage defaultInstance = new Builder().BuildPartial(); + public static NestedMessage DefaultInstance { + get { return defaultInstance; } + } + + public override NestedMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NestedMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_NestedMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<NestedMessage, NestedMessage.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_NestedMessage__FieldAccessorTable; } + } + + private bool hasBb; + private int bb_ = 0; + public bool HasBb { + get { return hasBb; } + } + public int Bb { + get { return bb_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasBb) { + output.WriteInt32(1, Bb); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasBb) { + size += pb::CodedOutputStream.ComputeInt32Size(1, Bb); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NestedMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NestedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NestedMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(NestedMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<NestedMessage, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NestedMessage result = new NestedMessage(); + + protected override NestedMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NestedMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return NestedMessage.Descriptor; } + } + + public override NestedMessage DefaultInstanceForType { + get { return NestedMessage.DefaultInstance; } + } + + public override NestedMessage BuildPartial() { + NestedMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NestedMessage) { + return MergeFrom((NestedMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NestedMessage other) { + if (other == NestedMessage.DefaultInstance) return this; + if (other.HasBb) { + Bb = other.Bb; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + Bb = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasBb { + get { return result.HasBb; } + } + public int Bb { + get { return result.Bb; } + set { SetBb(value); } + } + public Builder SetBb(int value) { + result.hasBb = true; + result.bb_ = value; + return this; + } + public Builder ClearBb() { + result.hasBb = false; + result.bb_ = 0; + return this; + } + } + } + + public sealed partial class OptionalGroup : pb::GeneratedMessage<OptionalGroup, OptionalGroup.Builder> { + private static readonly OptionalGroup defaultInstance = new Builder().BuildPartial(); + public static OptionalGroup DefaultInstance { + get { return defaultInstance; } + } + + public override OptionalGroup DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override OptionalGroup ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<OptionalGroup, OptionalGroup.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_OptionalGroup__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(17, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(17, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static OptionalGroup ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static OptionalGroup ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static OptionalGroup ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static OptionalGroup ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static OptionalGroup ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(OptionalGroup prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<OptionalGroup, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + OptionalGroup result = new OptionalGroup(); + + protected override OptionalGroup MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new OptionalGroup(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return OptionalGroup.Descriptor; } + } + + public override OptionalGroup DefaultInstanceForType { + get { return OptionalGroup.DefaultInstance; } + } + + public override OptionalGroup BuildPartial() { + OptionalGroup returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is OptionalGroup) { + return MergeFrom((OptionalGroup) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(OptionalGroup other) { + if (other == OptionalGroup.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 136: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + public sealed partial class RepeatedGroup : pb::GeneratedMessage<RepeatedGroup, RepeatedGroup.Builder> { + private static readonly RepeatedGroup defaultInstance = new Builder().BuildPartial(); + public static RepeatedGroup DefaultInstance { + get { return defaultInstance; } + } + + public override RepeatedGroup DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override RepeatedGroup ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<RepeatedGroup, RepeatedGroup.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllTypes_RepeatedGroup__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(47, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(47, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static RepeatedGroup ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RepeatedGroup ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(RepeatedGroup prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<RepeatedGroup, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + RepeatedGroup result = new RepeatedGroup(); + + protected override RepeatedGroup MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new RepeatedGroup(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return RepeatedGroup.Descriptor; } + } + + public override RepeatedGroup DefaultInstanceForType { + get { return RepeatedGroup.DefaultInstance; } + } + + public override RepeatedGroup BuildPartial() { + RepeatedGroup returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is RepeatedGroup) { + return MergeFrom((RepeatedGroup) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(RepeatedGroup other) { + if (other == RepeatedGroup.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 376: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + } + #endregion + + private bool hasOptionalInt32; + private int optionalInt32_ = 0; + public bool HasOptionalInt32 { + get { return hasOptionalInt32; } + } + public int OptionalInt32 { + get { return optionalInt32_; } + } + + private bool hasOptionalInt64; + private long optionalInt64_ = 0L; + public bool HasOptionalInt64 { + get { return hasOptionalInt64; } + } + public long OptionalInt64 { + get { return optionalInt64_; } + } + + private bool hasOptionalUint32; + private uint optionalUint32_ = 0; + public bool HasOptionalUint32 { + get { return hasOptionalUint32; } + } + public uint OptionalUint32 { + get { return optionalUint32_; } + } + + private bool hasOptionalUint64; + private ulong optionalUint64_ = 0UL; + public bool HasOptionalUint64 { + get { return hasOptionalUint64; } + } + public ulong OptionalUint64 { + get { return optionalUint64_; } + } + + private bool hasOptionalSint32; + private int optionalSint32_ = 0; + public bool HasOptionalSint32 { + get { return hasOptionalSint32; } + } + public int OptionalSint32 { + get { return optionalSint32_; } + } + + private bool hasOptionalSint64; + private long optionalSint64_ = 0; + public bool HasOptionalSint64 { + get { return hasOptionalSint64; } + } + public long OptionalSint64 { + get { return optionalSint64_; } + } + + private bool hasOptionalFixed32; + private uint optionalFixed32_ = 0; + public bool HasOptionalFixed32 { + get { return hasOptionalFixed32; } + } + public uint OptionalFixed32 { + get { return optionalFixed32_; } + } + + private bool hasOptionalFixed64; + private ulong optionalFixed64_ = 0; + public bool HasOptionalFixed64 { + get { return hasOptionalFixed64; } + } + public ulong OptionalFixed64 { + get { return optionalFixed64_; } + } + + private bool hasOptionalSfixed32; + private int optionalSfixed32_ = 0; + public bool HasOptionalSfixed32 { + get { return hasOptionalSfixed32; } + } + public int OptionalSfixed32 { + get { return optionalSfixed32_; } + } + + private bool hasOptionalSfixed64; + private long optionalSfixed64_ = 0; + public bool HasOptionalSfixed64 { + get { return hasOptionalSfixed64; } + } + public long OptionalSfixed64 { + get { return optionalSfixed64_; } + } + + private bool hasOptionalFloat; + private float optionalFloat_ = 0F; + public bool HasOptionalFloat { + get { return hasOptionalFloat; } + } + public float OptionalFloat { + get { return optionalFloat_; } + } + + private bool hasOptionalDouble; + private double optionalDouble_ = 0D; + public bool HasOptionalDouble { + get { return hasOptionalDouble; } + } + public double OptionalDouble { + get { return optionalDouble_; } + } + + private bool hasOptionalBool; + private bool optionalBool_ = false; + public bool HasOptionalBool { + get { return hasOptionalBool; } + } + public bool OptionalBool { + get { return optionalBool_; } + } + + private bool hasOptionalString; + private string optionalString_ = ""; + public bool HasOptionalString { + get { return hasOptionalString; } + } + public string OptionalString { + get { return optionalString_; } + } + + private bool hasOptionalBytes; + private pb::ByteString optionalBytes_ = pb::ByteString.Empty; + public bool HasOptionalBytes { + get { return hasOptionalBytes; } + } + public pb::ByteString OptionalBytes { + get { return optionalBytes_; } + } + + private bool hasOptionalGroup; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup optionalGroup_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.DefaultInstance; + public bool HasOptionalGroup { + get { return hasOptionalGroup; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup OptionalGroup { + get { return optionalGroup_; } + } + + private bool hasOptionalNestedMessage; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance; + public bool HasOptionalNestedMessage { + get { return hasOptionalNestedMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage OptionalNestedMessage { + get { return optionalNestedMessage_; } + } + + private bool hasOptionalForeignMessage; + private global::Google.ProtocolBuffers.TestProtos.ForeignMessage optionalForeignMessage_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + public bool HasOptionalForeignMessage { + get { return hasOptionalForeignMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage OptionalForeignMessage { + get { return optionalForeignMessage_; } + } + + private bool hasOptionalImportMessage; + private global::Google.ProtocolBuffers.TestProtos.ImportMessage optionalImportMessage_ = global::Google.ProtocolBuffers.TestProtos.ImportMessage.DefaultInstance; + public bool HasOptionalImportMessage { + get { return hasOptionalImportMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportMessage OptionalImportMessage { + get { return optionalImportMessage_; } + } + + private bool hasOptionalNestedEnum; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum optionalNestedEnum_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum.FOO; + public bool HasOptionalNestedEnum { + get { return hasOptionalNestedEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum OptionalNestedEnum { + get { return optionalNestedEnum_; } + } + + private bool hasOptionalForeignEnum; + private global::Google.ProtocolBuffers.TestProtos.ForeignEnum optionalForeignEnum_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_FOO; + public bool HasOptionalForeignEnum { + get { return hasOptionalForeignEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum OptionalForeignEnum { + get { return optionalForeignEnum_; } + } + + private bool hasOptionalImportEnum; + private global::Google.ProtocolBuffers.TestProtos.ImportEnum optionalImportEnum_ = global::Google.ProtocolBuffers.TestProtos.ImportEnum.IMPORT_FOO; + public bool HasOptionalImportEnum { + get { return hasOptionalImportEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum OptionalImportEnum { + get { return optionalImportEnum_; } + } + + private bool hasOptionalStringPiece; + private string optionalStringPiece_ = ""; + public bool HasOptionalStringPiece { + get { return hasOptionalStringPiece; } + } + public string OptionalStringPiece { + get { return optionalStringPiece_; } + } + + private bool hasOptionalCord; + private string optionalCord_ = ""; + public bool HasOptionalCord { + get { return hasOptionalCord; } + } + public string OptionalCord { + get { return optionalCord_; } + } + + private pbc::PopsicleList<int> repeatedInt32_ = new pbc::PopsicleList<int>(); + public scg::IList<int> RepeatedInt32List { + get { return pbc::Lists.AsReadOnly(repeatedInt32_); } + } + public int RepeatedInt32Count { + get { return repeatedInt32_.Count; } + } + public int GetRepeatedInt32(int index) { + return repeatedInt32_[index]; + } + + private pbc::PopsicleList<long> repeatedInt64_ = new pbc::PopsicleList<long>(); + public scg::IList<long> RepeatedInt64List { + get { return pbc::Lists.AsReadOnly(repeatedInt64_); } + } + public int RepeatedInt64Count { + get { return repeatedInt64_.Count; } + } + public long GetRepeatedInt64(int index) { + return repeatedInt64_[index]; + } + + private pbc::PopsicleList<uint> repeatedUint32_ = new pbc::PopsicleList<uint>(); + public scg::IList<uint> RepeatedUint32List { + get { return pbc::Lists.AsReadOnly(repeatedUint32_); } + } + public int RepeatedUint32Count { + get { return repeatedUint32_.Count; } + } + public uint GetRepeatedUint32(int index) { + return repeatedUint32_[index]; + } + + private pbc::PopsicleList<ulong> repeatedUint64_ = new pbc::PopsicleList<ulong>(); + public scg::IList<ulong> RepeatedUint64List { + get { return pbc::Lists.AsReadOnly(repeatedUint64_); } + } + public int RepeatedUint64Count { + get { return repeatedUint64_.Count; } + } + public ulong GetRepeatedUint64(int index) { + return repeatedUint64_[index]; + } + + private pbc::PopsicleList<int> repeatedSint32_ = new pbc::PopsicleList<int>(); + public scg::IList<int> RepeatedSint32List { + get { return pbc::Lists.AsReadOnly(repeatedSint32_); } + } + public int RepeatedSint32Count { + get { return repeatedSint32_.Count; } + } + public int GetRepeatedSint32(int index) { + return repeatedSint32_[index]; + } + + private pbc::PopsicleList<long> repeatedSint64_ = new pbc::PopsicleList<long>(); + public scg::IList<long> RepeatedSint64List { + get { return pbc::Lists.AsReadOnly(repeatedSint64_); } + } + public int RepeatedSint64Count { + get { return repeatedSint64_.Count; } + } + public long GetRepeatedSint64(int index) { + return repeatedSint64_[index]; + } + + private pbc::PopsicleList<uint> repeatedFixed32_ = new pbc::PopsicleList<uint>(); + public scg::IList<uint> RepeatedFixed32List { + get { return pbc::Lists.AsReadOnly(repeatedFixed32_); } + } + public int RepeatedFixed32Count { + get { return repeatedFixed32_.Count; } + } + public uint GetRepeatedFixed32(int index) { + return repeatedFixed32_[index]; + } + + private pbc::PopsicleList<ulong> repeatedFixed64_ = new pbc::PopsicleList<ulong>(); + public scg::IList<ulong> RepeatedFixed64List { + get { return pbc::Lists.AsReadOnly(repeatedFixed64_); } + } + public int RepeatedFixed64Count { + get { return repeatedFixed64_.Count; } + } + public ulong GetRepeatedFixed64(int index) { + return repeatedFixed64_[index]; + } + + private pbc::PopsicleList<int> repeatedSfixed32_ = new pbc::PopsicleList<int>(); + public scg::IList<int> RepeatedSfixed32List { + get { return pbc::Lists.AsReadOnly(repeatedSfixed32_); } + } + public int RepeatedSfixed32Count { + get { return repeatedSfixed32_.Count; } + } + public int GetRepeatedSfixed32(int index) { + return repeatedSfixed32_[index]; + } + + private pbc::PopsicleList<long> repeatedSfixed64_ = new pbc::PopsicleList<long>(); + public scg::IList<long> RepeatedSfixed64List { + get { return pbc::Lists.AsReadOnly(repeatedSfixed64_); } + } + public int RepeatedSfixed64Count { + get { return repeatedSfixed64_.Count; } + } + public long GetRepeatedSfixed64(int index) { + return repeatedSfixed64_[index]; + } + + private pbc::PopsicleList<float> repeatedFloat_ = new pbc::PopsicleList<float>(); + public scg::IList<float> RepeatedFloatList { + get { return pbc::Lists.AsReadOnly(repeatedFloat_); } + } + public int RepeatedFloatCount { + get { return repeatedFloat_.Count; } + } + public float GetRepeatedFloat(int index) { + return repeatedFloat_[index]; + } + + private pbc::PopsicleList<double> repeatedDouble_ = new pbc::PopsicleList<double>(); + public scg::IList<double> RepeatedDoubleList { + get { return pbc::Lists.AsReadOnly(repeatedDouble_); } + } + public int RepeatedDoubleCount { + get { return repeatedDouble_.Count; } + } + public double GetRepeatedDouble(int index) { + return repeatedDouble_[index]; + } + + private pbc::PopsicleList<bool> repeatedBool_ = new pbc::PopsicleList<bool>(); + public scg::IList<bool> RepeatedBoolList { + get { return pbc::Lists.AsReadOnly(repeatedBool_); } + } + public int RepeatedBoolCount { + get { return repeatedBool_.Count; } + } + public bool GetRepeatedBool(int index) { + return repeatedBool_[index]; + } + + private pbc::PopsicleList<string> repeatedString_ = new pbc::PopsicleList<string>(); + public scg::IList<string> RepeatedStringList { + get { return pbc::Lists.AsReadOnly(repeatedString_); } + } + public int RepeatedStringCount { + get { return repeatedString_.Count; } + } + public string GetRepeatedString(int index) { + return repeatedString_[index]; + } + + private pbc::PopsicleList<pb::ByteString> repeatedBytes_ = new pbc::PopsicleList<pb::ByteString>(); + public scg::IList<pb::ByteString> RepeatedBytesList { + get { return pbc::Lists.AsReadOnly(repeatedBytes_); } + } + public int RepeatedBytesCount { + get { return repeatedBytes_.Count; } + } + public pb::ByteString GetRepeatedBytes(int index) { + return repeatedBytes_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup> repeatedGroup_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup> RepeatedGroupList { + get { return repeatedGroup_; } + } + public int RepeatedGroupCount { + get { return repeatedGroup_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup GetRepeatedGroup(int index) { + return repeatedGroup_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage> repeatedNestedMessage_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage> RepeatedNestedMessageList { + get { return repeatedNestedMessage_; } + } + public int RepeatedNestedMessageCount { + get { return repeatedNestedMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage GetRepeatedNestedMessage(int index) { + return repeatedNestedMessage_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> repeatedForeignMessage_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> RepeatedForeignMessageList { + get { return repeatedForeignMessage_; } + } + public int RepeatedForeignMessageCount { + get { return repeatedForeignMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetRepeatedForeignMessage(int index) { + return repeatedForeignMessage_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ImportMessage> repeatedImportMessage_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ImportMessage>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ImportMessage> RepeatedImportMessageList { + get { return repeatedImportMessage_; } + } + public int RepeatedImportMessageCount { + get { return repeatedImportMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportMessage GetRepeatedImportMessage(int index) { + return repeatedImportMessage_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum> repeatedNestedEnum_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum> RepeatedNestedEnumList { + get { return pbc::Lists.AsReadOnly(repeatedNestedEnum_); } + } + public int RepeatedNestedEnumCount { + get { return repeatedNestedEnum_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum GetRepeatedNestedEnum(int index) { + return repeatedNestedEnum_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> repeatedForeignEnum_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignEnum>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> RepeatedForeignEnumList { + get { return pbc::Lists.AsReadOnly(repeatedForeignEnum_); } + } + public int RepeatedForeignEnumCount { + get { return repeatedForeignEnum_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetRepeatedForeignEnum(int index) { + return repeatedForeignEnum_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ImportEnum> repeatedImportEnum_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ImportEnum>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ImportEnum> RepeatedImportEnumList { + get { return pbc::Lists.AsReadOnly(repeatedImportEnum_); } + } + public int RepeatedImportEnumCount { + get { return repeatedImportEnum_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum GetRepeatedImportEnum(int index) { + return repeatedImportEnum_[index]; + } + + private pbc::PopsicleList<string> repeatedStringPiece_ = new pbc::PopsicleList<string>(); + public scg::IList<string> RepeatedStringPieceList { + get { return pbc::Lists.AsReadOnly(repeatedStringPiece_); } + } + public int RepeatedStringPieceCount { + get { return repeatedStringPiece_.Count; } + } + public string GetRepeatedStringPiece(int index) { + return repeatedStringPiece_[index]; + } + + private pbc::PopsicleList<string> repeatedCord_ = new pbc::PopsicleList<string>(); + public scg::IList<string> RepeatedCordList { + get { return pbc::Lists.AsReadOnly(repeatedCord_); } + } + public int RepeatedCordCount { + get { return repeatedCord_.Count; } + } + public string GetRepeatedCord(int index) { + return repeatedCord_[index]; + } + + private bool hasDefaultInt32; + private int defaultInt32_ = 41; + public bool HasDefaultInt32 { + get { return hasDefaultInt32; } + } + public int DefaultInt32 { + get { return defaultInt32_; } + } + + private bool hasDefaultInt64; + private long defaultInt64_ = 42L; + public bool HasDefaultInt64 { + get { return hasDefaultInt64; } + } + public long DefaultInt64 { + get { return defaultInt64_; } + } + + private bool hasDefaultUint32; + private uint defaultUint32_ = 43; + public bool HasDefaultUint32 { + get { return hasDefaultUint32; } + } + public uint DefaultUint32 { + get { return defaultUint32_; } + } + + private bool hasDefaultUint64; + private ulong defaultUint64_ = 44UL; + public bool HasDefaultUint64 { + get { return hasDefaultUint64; } + } + public ulong DefaultUint64 { + get { return defaultUint64_; } + } + + private bool hasDefaultSint32; + private int defaultSint32_ = -45; + public bool HasDefaultSint32 { + get { return hasDefaultSint32; } + } + public int DefaultSint32 { + get { return defaultSint32_; } + } + + private bool hasDefaultSint64; + private long defaultSint64_ = 46; + public bool HasDefaultSint64 { + get { return hasDefaultSint64; } + } + public long DefaultSint64 { + get { return defaultSint64_; } + } + + private bool hasDefaultFixed32; + private uint defaultFixed32_ = 47; + public bool HasDefaultFixed32 { + get { return hasDefaultFixed32; } + } + public uint DefaultFixed32 { + get { return defaultFixed32_; } + } + + private bool hasDefaultFixed64; + private ulong defaultFixed64_ = 48; + public bool HasDefaultFixed64 { + get { return hasDefaultFixed64; } + } + public ulong DefaultFixed64 { + get { return defaultFixed64_; } + } + + private bool hasDefaultSfixed32; + private int defaultSfixed32_ = 49; + public bool HasDefaultSfixed32 { + get { return hasDefaultSfixed32; } + } + public int DefaultSfixed32 { + get { return defaultSfixed32_; } + } + + private bool hasDefaultSfixed64; + private long defaultSfixed64_ = -50; + public bool HasDefaultSfixed64 { + get { return hasDefaultSfixed64; } + } + public long DefaultSfixed64 { + get { return defaultSfixed64_; } + } + + private bool hasDefaultFloat; + private float defaultFloat_ = 51.5F; + public bool HasDefaultFloat { + get { return hasDefaultFloat; } + } + public float DefaultFloat { + get { return defaultFloat_; } + } + + private bool hasDefaultDouble; + private double defaultDouble_ = 52000D; + public bool HasDefaultDouble { + get { return hasDefaultDouble; } + } + public double DefaultDouble { + get { return defaultDouble_; } + } + + private bool hasDefaultBool; + private bool defaultBool_ = true; + public bool HasDefaultBool { + get { return hasDefaultBool; } + } + public bool DefaultBool { + get { return defaultBool_; } + } + + private bool hasDefaultString; + private string defaultString_ = "hello"; + public bool HasDefaultString { + get { return hasDefaultString; } + } + public string DefaultString { + get { return defaultString_; } + } + + private bool hasDefaultBytes; + private pb::ByteString defaultBytes_ = (pb::ByteString) global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Descriptor.Fields[62].DefaultValue; + public bool HasDefaultBytes { + get { return hasDefaultBytes; } + } + public pb::ByteString DefaultBytes { + get { return defaultBytes_; } + } + + private bool hasDefaultNestedEnum; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum defaultNestedEnum_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum.BAR; + public bool HasDefaultNestedEnum { + get { return hasDefaultNestedEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum DefaultNestedEnum { + get { return defaultNestedEnum_; } + } + + private bool hasDefaultForeignEnum; + private global::Google.ProtocolBuffers.TestProtos.ForeignEnum defaultForeignEnum_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_BAR; + public bool HasDefaultForeignEnum { + get { return hasDefaultForeignEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum DefaultForeignEnum { + get { return defaultForeignEnum_; } + } + + private bool hasDefaultImportEnum; + private global::Google.ProtocolBuffers.TestProtos.ImportEnum defaultImportEnum_ = global::Google.ProtocolBuffers.TestProtos.ImportEnum.IMPORT_BAR; + public bool HasDefaultImportEnum { + get { return hasDefaultImportEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum DefaultImportEnum { + get { return defaultImportEnum_; } + } + + private bool hasDefaultStringPiece; + private string defaultStringPiece_ = "abc"; + public bool HasDefaultStringPiece { + get { return hasDefaultStringPiece; } + } + public string DefaultStringPiece { + get { return defaultStringPiece_; } + } + + private bool hasDefaultCord; + private string defaultCord_ = "123"; + public bool HasDefaultCord { + get { return hasDefaultCord; } + } + public string DefaultCord { + get { return defaultCord_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasOptionalInt32) { + output.WriteInt32(1, OptionalInt32); + } + if (HasOptionalInt64) { + output.WriteInt64(2, OptionalInt64); + } + if (HasOptionalUint32) { + output.WriteUInt32(3, OptionalUint32); + } + if (HasOptionalUint64) { + output.WriteUInt64(4, OptionalUint64); + } + if (HasOptionalSint32) { + output.WriteSInt32(5, OptionalSint32); + } + if (HasOptionalSint64) { + output.WriteSInt64(6, OptionalSint64); + } + if (HasOptionalFixed32) { + output.WriteFixed32(7, OptionalFixed32); + } + if (HasOptionalFixed64) { + output.WriteFixed64(8, OptionalFixed64); + } + if (HasOptionalSfixed32) { + output.WriteSFixed32(9, OptionalSfixed32); + } + if (HasOptionalSfixed64) { + output.WriteSFixed64(10, OptionalSfixed64); + } + if (HasOptionalFloat) { + output.WriteFloat(11, OptionalFloat); + } + if (HasOptionalDouble) { + output.WriteDouble(12, OptionalDouble); + } + if (HasOptionalBool) { + output.WriteBool(13, OptionalBool); + } + if (HasOptionalString) { + output.WriteString(14, OptionalString); + } + if (HasOptionalBytes) { + output.WriteBytes(15, OptionalBytes); + } + if (HasOptionalGroup) { + output.WriteGroup(16, OptionalGroup); + } + if (HasOptionalNestedMessage) { + output.WriteMessage(18, OptionalNestedMessage); + } + if (HasOptionalForeignMessage) { + output.WriteMessage(19, OptionalForeignMessage); + } + if (HasOptionalImportMessage) { + output.WriteMessage(20, OptionalImportMessage); + } + if (HasOptionalNestedEnum) { + output.WriteEnum(21, (int) OptionalNestedEnum); + } + if (HasOptionalForeignEnum) { + output.WriteEnum(22, (int) OptionalForeignEnum); + } + if (HasOptionalImportEnum) { + output.WriteEnum(23, (int) OptionalImportEnum); + } + if (HasOptionalStringPiece) { + output.WriteString(24, OptionalStringPiece); + } + if (HasOptionalCord) { + output.WriteString(25, OptionalCord); + } + foreach (int element in RepeatedInt32List) { + output.WriteInt32(31, element); + } + foreach (long element in RepeatedInt64List) { + output.WriteInt64(32, element); + } + foreach (uint element in RepeatedUint32List) { + output.WriteUInt32(33, element); + } + foreach (ulong element in RepeatedUint64List) { + output.WriteUInt64(34, element); + } + foreach (int element in RepeatedSint32List) { + output.WriteSInt32(35, element); + } + foreach (long element in RepeatedSint64List) { + output.WriteSInt64(36, element); + } + foreach (uint element in RepeatedFixed32List) { + output.WriteFixed32(37, element); + } + foreach (ulong element in RepeatedFixed64List) { + output.WriteFixed64(38, element); + } + foreach (int element in RepeatedSfixed32List) { + output.WriteSFixed32(39, element); + } + foreach (long element in RepeatedSfixed64List) { + output.WriteSFixed64(40, element); + } + foreach (float element in RepeatedFloatList) { + output.WriteFloat(41, element); + } + foreach (double element in RepeatedDoubleList) { + output.WriteDouble(42, element); + } + foreach (bool element in RepeatedBoolList) { + output.WriteBool(43, element); + } + foreach (string element in RepeatedStringList) { + output.WriteString(44, element); + } + foreach (pb::ByteString element in RepeatedBytesList) { + output.WriteBytes(45, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup element in RepeatedGroupList) { + output.WriteGroup(46, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage element in RepeatedNestedMessageList) { + output.WriteMessage(48, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedForeignMessageList) { + output.WriteMessage(49, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ImportMessage element in RepeatedImportMessageList) { + output.WriteMessage(50, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum element in RepeatedNestedEnumList) { + output.WriteEnum(51, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedForeignEnumList) { + output.WriteEnum(52, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ImportEnum element in RepeatedImportEnumList) { + output.WriteEnum(53, (int) element); + } + foreach (string element in RepeatedStringPieceList) { + output.WriteString(54, element); + } + foreach (string element in RepeatedCordList) { + output.WriteString(55, element); + } + if (HasDefaultInt32) { + output.WriteInt32(61, DefaultInt32); + } + if (HasDefaultInt64) { + output.WriteInt64(62, DefaultInt64); + } + if (HasDefaultUint32) { + output.WriteUInt32(63, DefaultUint32); + } + if (HasDefaultUint64) { + output.WriteUInt64(64, DefaultUint64); + } + if (HasDefaultSint32) { + output.WriteSInt32(65, DefaultSint32); + } + if (HasDefaultSint64) { + output.WriteSInt64(66, DefaultSint64); + } + if (HasDefaultFixed32) { + output.WriteFixed32(67, DefaultFixed32); + } + if (HasDefaultFixed64) { + output.WriteFixed64(68, DefaultFixed64); + } + if (HasDefaultSfixed32) { + output.WriteSFixed32(69, DefaultSfixed32); + } + if (HasDefaultSfixed64) { + output.WriteSFixed64(70, DefaultSfixed64); + } + if (HasDefaultFloat) { + output.WriteFloat(71, DefaultFloat); + } + if (HasDefaultDouble) { + output.WriteDouble(72, DefaultDouble); + } + if (HasDefaultBool) { + output.WriteBool(73, DefaultBool); + } + if (HasDefaultString) { + output.WriteString(74, DefaultString); + } + if (HasDefaultBytes) { + output.WriteBytes(75, DefaultBytes); + } + if (HasDefaultNestedEnum) { + output.WriteEnum(81, (int) DefaultNestedEnum); + } + if (HasDefaultForeignEnum) { + output.WriteEnum(82, (int) DefaultForeignEnum); + } + if (HasDefaultImportEnum) { + output.WriteEnum(83, (int) DefaultImportEnum); + } + if (HasDefaultStringPiece) { + output.WriteString(84, DefaultStringPiece); + } + if (HasDefaultCord) { + output.WriteString(85, DefaultCord); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasOptionalInt32) { + size += pb::CodedOutputStream.ComputeInt32Size(1, OptionalInt32); + } + if (HasOptionalInt64) { + size += pb::CodedOutputStream.ComputeInt64Size(2, OptionalInt64); + } + if (HasOptionalUint32) { + size += pb::CodedOutputStream.ComputeUInt32Size(3, OptionalUint32); + } + if (HasOptionalUint64) { + size += pb::CodedOutputStream.ComputeUInt64Size(4, OptionalUint64); + } + if (HasOptionalSint32) { + size += pb::CodedOutputStream.ComputeSInt32Size(5, OptionalSint32); + } + if (HasOptionalSint64) { + size += pb::CodedOutputStream.ComputeSInt64Size(6, OptionalSint64); + } + if (HasOptionalFixed32) { + size += pb::CodedOutputStream.ComputeFixed32Size(7, OptionalFixed32); + } + if (HasOptionalFixed64) { + size += pb::CodedOutputStream.ComputeFixed64Size(8, OptionalFixed64); + } + if (HasOptionalSfixed32) { + size += pb::CodedOutputStream.ComputeSFixed32Size(9, OptionalSfixed32); + } + if (HasOptionalSfixed64) { + size += pb::CodedOutputStream.ComputeSFixed64Size(10, OptionalSfixed64); + } + if (HasOptionalFloat) { + size += pb::CodedOutputStream.ComputeFloatSize(11, OptionalFloat); + } + if (HasOptionalDouble) { + size += pb::CodedOutputStream.ComputeDoubleSize(12, OptionalDouble); + } + if (HasOptionalBool) { + size += pb::CodedOutputStream.ComputeBoolSize(13, OptionalBool); + } + if (HasOptionalString) { + size += pb::CodedOutputStream.ComputeStringSize(14, OptionalString); + } + if (HasOptionalBytes) { + size += pb::CodedOutputStream.ComputeBytesSize(15, OptionalBytes); + } + if (HasOptionalGroup) { + size += pb::CodedOutputStream.ComputeGroupSize(16, OptionalGroup); + } + if (HasOptionalNestedMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(18, OptionalNestedMessage); + } + if (HasOptionalForeignMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(19, OptionalForeignMessage); + } + if (HasOptionalImportMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(20, OptionalImportMessage); + } + if (HasOptionalNestedEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(21, (int) OptionalNestedEnum); + } + if (HasOptionalForeignEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(22, (int) OptionalForeignEnum); + } + if (HasOptionalImportEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(23, (int) OptionalImportEnum); + } + if (HasOptionalStringPiece) { + size += pb::CodedOutputStream.ComputeStringSize(24, OptionalStringPiece); + } + if (HasOptionalCord) { + size += pb::CodedOutputStream.ComputeStringSize(25, OptionalCord); + } + foreach (int element in RepeatedInt32List) { + size += pb::CodedOutputStream.ComputeInt32Size(31, element); + } + foreach (long element in RepeatedInt64List) { + size += pb::CodedOutputStream.ComputeInt64Size(32, element); + } + foreach (uint element in RepeatedUint32List) { + size += pb::CodedOutputStream.ComputeUInt32Size(33, element); + } + foreach (ulong element in RepeatedUint64List) { + size += pb::CodedOutputStream.ComputeUInt64Size(34, element); + } + foreach (int element in RepeatedSint32List) { + size += pb::CodedOutputStream.ComputeSInt32Size(35, element); + } + foreach (long element in RepeatedSint64List) { + size += pb::CodedOutputStream.ComputeSInt64Size(36, element); + } + foreach (uint element in RepeatedFixed32List) { + size += pb::CodedOutputStream.ComputeFixed32Size(37, element); + } + foreach (ulong element in RepeatedFixed64List) { + size += pb::CodedOutputStream.ComputeFixed64Size(38, element); + } + foreach (int element in RepeatedSfixed32List) { + size += pb::CodedOutputStream.ComputeSFixed32Size(39, element); + } + foreach (long element in RepeatedSfixed64List) { + size += pb::CodedOutputStream.ComputeSFixed64Size(40, element); + } + foreach (float element in RepeatedFloatList) { + size += pb::CodedOutputStream.ComputeFloatSize(41, element); + } + foreach (double element in RepeatedDoubleList) { + size += pb::CodedOutputStream.ComputeDoubleSize(42, element); + } + foreach (bool element in RepeatedBoolList) { + size += pb::CodedOutputStream.ComputeBoolSize(43, element); + } + foreach (string element in RepeatedStringList) { + size += pb::CodedOutputStream.ComputeStringSize(44, element); + } + foreach (pb::ByteString element in RepeatedBytesList) { + size += pb::CodedOutputStream.ComputeBytesSize(45, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup element in RepeatedGroupList) { + size += pb::CodedOutputStream.ComputeGroupSize(46, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage element in RepeatedNestedMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(48, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedForeignMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(49, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ImportMessage element in RepeatedImportMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(50, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum element in RepeatedNestedEnumList) { + size += pb::CodedOutputStream.ComputeEnumSize(51, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedForeignEnumList) { + size += pb::CodedOutputStream.ComputeEnumSize(52, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ImportEnum element in RepeatedImportEnumList) { + size += pb::CodedOutputStream.ComputeEnumSize(53, (int) element); + } + foreach (string element in RepeatedStringPieceList) { + size += pb::CodedOutputStream.ComputeStringSize(54, element); + } + foreach (string element in RepeatedCordList) { + size += pb::CodedOutputStream.ComputeStringSize(55, element); + } + if (HasDefaultInt32) { + size += pb::CodedOutputStream.ComputeInt32Size(61, DefaultInt32); + } + if (HasDefaultInt64) { + size += pb::CodedOutputStream.ComputeInt64Size(62, DefaultInt64); + } + if (HasDefaultUint32) { + size += pb::CodedOutputStream.ComputeUInt32Size(63, DefaultUint32); + } + if (HasDefaultUint64) { + size += pb::CodedOutputStream.ComputeUInt64Size(64, DefaultUint64); + } + if (HasDefaultSint32) { + size += pb::CodedOutputStream.ComputeSInt32Size(65, DefaultSint32); + } + if (HasDefaultSint64) { + size += pb::CodedOutputStream.ComputeSInt64Size(66, DefaultSint64); + } + if (HasDefaultFixed32) { + size += pb::CodedOutputStream.ComputeFixed32Size(67, DefaultFixed32); + } + if (HasDefaultFixed64) { + size += pb::CodedOutputStream.ComputeFixed64Size(68, DefaultFixed64); + } + if (HasDefaultSfixed32) { + size += pb::CodedOutputStream.ComputeSFixed32Size(69, DefaultSfixed32); + } + if (HasDefaultSfixed64) { + size += pb::CodedOutputStream.ComputeSFixed64Size(70, DefaultSfixed64); + } + if (HasDefaultFloat) { + size += pb::CodedOutputStream.ComputeFloatSize(71, DefaultFloat); + } + if (HasDefaultDouble) { + size += pb::CodedOutputStream.ComputeDoubleSize(72, DefaultDouble); + } + if (HasDefaultBool) { + size += pb::CodedOutputStream.ComputeBoolSize(73, DefaultBool); + } + if (HasDefaultString) { + size += pb::CodedOutputStream.ComputeStringSize(74, DefaultString); + } + if (HasDefaultBytes) { + size += pb::CodedOutputStream.ComputeBytesSize(75, DefaultBytes); + } + if (HasDefaultNestedEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(81, (int) DefaultNestedEnum); + } + if (HasDefaultForeignEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(82, (int) DefaultForeignEnum); + } + if (HasDefaultImportEnum) { + size += pb::CodedOutputStream.ComputeEnumSize(83, (int) DefaultImportEnum); + } + if (HasDefaultStringPiece) { + size += pb::CodedOutputStream.ComputeStringSize(84, DefaultStringPiece); + } + if (HasDefaultCord) { + size += pb::CodedOutputStream.ComputeStringSize(85, DefaultCord); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestAllTypes ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestAllTypes ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestAllTypes ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestAllTypes ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestAllTypes ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestAllTypes ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestAllTypes ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestAllTypes ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestAllTypes prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestAllTypes, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestAllTypes result = new TestAllTypes(); + + protected override TestAllTypes MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestAllTypes(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestAllTypes.Descriptor; } + } + + public override TestAllTypes DefaultInstanceForType { + get { return TestAllTypes.DefaultInstance; } + } + + public override TestAllTypes BuildPartial() { + result.repeatedInt32_.MakeReadOnly(); + result.repeatedInt64_.MakeReadOnly(); + result.repeatedUint32_.MakeReadOnly(); + result.repeatedUint64_.MakeReadOnly(); + result.repeatedSint32_.MakeReadOnly(); + result.repeatedSint64_.MakeReadOnly(); + result.repeatedFixed32_.MakeReadOnly(); + result.repeatedFixed64_.MakeReadOnly(); + result.repeatedSfixed32_.MakeReadOnly(); + result.repeatedSfixed64_.MakeReadOnly(); + result.repeatedFloat_.MakeReadOnly(); + result.repeatedDouble_.MakeReadOnly(); + result.repeatedBool_.MakeReadOnly(); + result.repeatedString_.MakeReadOnly(); + result.repeatedBytes_.MakeReadOnly(); + result.repeatedGroup_.MakeReadOnly(); + result.repeatedNestedMessage_.MakeReadOnly(); + result.repeatedForeignMessage_.MakeReadOnly(); + result.repeatedImportMessage_.MakeReadOnly(); + result.repeatedNestedEnum_.MakeReadOnly(); + result.repeatedForeignEnum_.MakeReadOnly(); + result.repeatedImportEnum_.MakeReadOnly(); + result.repeatedStringPiece_.MakeReadOnly(); + result.repeatedCord_.MakeReadOnly(); + TestAllTypes returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestAllTypes) { + return MergeFrom((TestAllTypes) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestAllTypes other) { + if (other == TestAllTypes.DefaultInstance) return this; + if (other.HasOptionalInt32) { + OptionalInt32 = other.OptionalInt32; + } + if (other.HasOptionalInt64) { + OptionalInt64 = other.OptionalInt64; + } + if (other.HasOptionalUint32) { + OptionalUint32 = other.OptionalUint32; + } + if (other.HasOptionalUint64) { + OptionalUint64 = other.OptionalUint64; + } + if (other.HasOptionalSint32) { + OptionalSint32 = other.OptionalSint32; + } + if (other.HasOptionalSint64) { + OptionalSint64 = other.OptionalSint64; + } + if (other.HasOptionalFixed32) { + OptionalFixed32 = other.OptionalFixed32; + } + if (other.HasOptionalFixed64) { + OptionalFixed64 = other.OptionalFixed64; + } + if (other.HasOptionalSfixed32) { + OptionalSfixed32 = other.OptionalSfixed32; + } + if (other.HasOptionalSfixed64) { + OptionalSfixed64 = other.OptionalSfixed64; + } + if (other.HasOptionalFloat) { + OptionalFloat = other.OptionalFloat; + } + if (other.HasOptionalDouble) { + OptionalDouble = other.OptionalDouble; + } + if (other.HasOptionalBool) { + OptionalBool = other.OptionalBool; + } + if (other.HasOptionalString) { + OptionalString = other.OptionalString; + } + if (other.HasOptionalBytes) { + OptionalBytes = other.OptionalBytes; + } + if (other.HasOptionalGroup) { + MergeOptionalGroup(other.OptionalGroup); + } + if (other.HasOptionalNestedMessage) { + MergeOptionalNestedMessage(other.OptionalNestedMessage); + } + if (other.HasOptionalForeignMessage) { + MergeOptionalForeignMessage(other.OptionalForeignMessage); + } + if (other.HasOptionalImportMessage) { + MergeOptionalImportMessage(other.OptionalImportMessage); + } + if (other.HasOptionalNestedEnum) { + OptionalNestedEnum = other.OptionalNestedEnum; + } + if (other.HasOptionalForeignEnum) { + OptionalForeignEnum = other.OptionalForeignEnum; + } + if (other.HasOptionalImportEnum) { + OptionalImportEnum = other.OptionalImportEnum; + } + if (other.HasOptionalStringPiece) { + OptionalStringPiece = other.OptionalStringPiece; + } + if (other.HasOptionalCord) { + OptionalCord = other.OptionalCord; + } + if (other.repeatedInt32_.Count != 0) { + base.AddRange(other.repeatedInt32_, result.repeatedInt32_); + } + if (other.repeatedInt64_.Count != 0) { + base.AddRange(other.repeatedInt64_, result.repeatedInt64_); + } + if (other.repeatedUint32_.Count != 0) { + base.AddRange(other.repeatedUint32_, result.repeatedUint32_); + } + if (other.repeatedUint64_.Count != 0) { + base.AddRange(other.repeatedUint64_, result.repeatedUint64_); + } + if (other.repeatedSint32_.Count != 0) { + base.AddRange(other.repeatedSint32_, result.repeatedSint32_); + } + if (other.repeatedSint64_.Count != 0) { + base.AddRange(other.repeatedSint64_, result.repeatedSint64_); + } + if (other.repeatedFixed32_.Count != 0) { + base.AddRange(other.repeatedFixed32_, result.repeatedFixed32_); + } + if (other.repeatedFixed64_.Count != 0) { + base.AddRange(other.repeatedFixed64_, result.repeatedFixed64_); + } + if (other.repeatedSfixed32_.Count != 0) { + base.AddRange(other.repeatedSfixed32_, result.repeatedSfixed32_); + } + if (other.repeatedSfixed64_.Count != 0) { + base.AddRange(other.repeatedSfixed64_, result.repeatedSfixed64_); + } + if (other.repeatedFloat_.Count != 0) { + base.AddRange(other.repeatedFloat_, result.repeatedFloat_); + } + if (other.repeatedDouble_.Count != 0) { + base.AddRange(other.repeatedDouble_, result.repeatedDouble_); + } + if (other.repeatedBool_.Count != 0) { + base.AddRange(other.repeatedBool_, result.repeatedBool_); + } + if (other.repeatedString_.Count != 0) { + base.AddRange(other.repeatedString_, result.repeatedString_); + } + if (other.repeatedBytes_.Count != 0) { + base.AddRange(other.repeatedBytes_, result.repeatedBytes_); + } + if (other.repeatedGroup_.Count != 0) { + base.AddRange(other.repeatedGroup_, result.repeatedGroup_); + } + if (other.repeatedNestedMessage_.Count != 0) { + base.AddRange(other.repeatedNestedMessage_, result.repeatedNestedMessage_); + } + if (other.repeatedForeignMessage_.Count != 0) { + base.AddRange(other.repeatedForeignMessage_, result.repeatedForeignMessage_); + } + if (other.repeatedImportMessage_.Count != 0) { + base.AddRange(other.repeatedImportMessage_, result.repeatedImportMessage_); + } + if (other.repeatedNestedEnum_.Count != 0) { + base.AddRange(other.repeatedNestedEnum_, result.repeatedNestedEnum_); + } + if (other.repeatedForeignEnum_.Count != 0) { + base.AddRange(other.repeatedForeignEnum_, result.repeatedForeignEnum_); + } + if (other.repeatedImportEnum_.Count != 0) { + base.AddRange(other.repeatedImportEnum_, result.repeatedImportEnum_); + } + if (other.repeatedStringPiece_.Count != 0) { + base.AddRange(other.repeatedStringPiece_, result.repeatedStringPiece_); + } + if (other.repeatedCord_.Count != 0) { + base.AddRange(other.repeatedCord_, result.repeatedCord_); + } + if (other.HasDefaultInt32) { + DefaultInt32 = other.DefaultInt32; + } + if (other.HasDefaultInt64) { + DefaultInt64 = other.DefaultInt64; + } + if (other.HasDefaultUint32) { + DefaultUint32 = other.DefaultUint32; + } + if (other.HasDefaultUint64) { + DefaultUint64 = other.DefaultUint64; + } + if (other.HasDefaultSint32) { + DefaultSint32 = other.DefaultSint32; + } + if (other.HasDefaultSint64) { + DefaultSint64 = other.DefaultSint64; + } + if (other.HasDefaultFixed32) { + DefaultFixed32 = other.DefaultFixed32; + } + if (other.HasDefaultFixed64) { + DefaultFixed64 = other.DefaultFixed64; + } + if (other.HasDefaultSfixed32) { + DefaultSfixed32 = other.DefaultSfixed32; + } + if (other.HasDefaultSfixed64) { + DefaultSfixed64 = other.DefaultSfixed64; + } + if (other.HasDefaultFloat) { + DefaultFloat = other.DefaultFloat; + } + if (other.HasDefaultDouble) { + DefaultDouble = other.DefaultDouble; + } + if (other.HasDefaultBool) { + DefaultBool = other.DefaultBool; + } + if (other.HasDefaultString) { + DefaultString = other.DefaultString; + } + if (other.HasDefaultBytes) { + DefaultBytes = other.DefaultBytes; + } + if (other.HasDefaultNestedEnum) { + DefaultNestedEnum = other.DefaultNestedEnum; + } + if (other.HasDefaultForeignEnum) { + DefaultForeignEnum = other.DefaultForeignEnum; + } + if (other.HasDefaultImportEnum) { + DefaultImportEnum = other.DefaultImportEnum; + } + if (other.HasDefaultStringPiece) { + DefaultStringPiece = other.DefaultStringPiece; + } + if (other.HasDefaultCord) { + DefaultCord = other.DefaultCord; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + OptionalInt32 = input.ReadInt32(); + break; + } + case 16: { + OptionalInt64 = input.ReadInt64(); + break; + } + case 24: { + OptionalUint32 = input.ReadUInt32(); + break; + } + case 32: { + OptionalUint64 = input.ReadUInt64(); + break; + } + case 40: { + OptionalSint32 = input.ReadSInt32(); + break; + } + case 48: { + OptionalSint64 = input.ReadSInt64(); + break; + } + case 61: { + OptionalFixed32 = input.ReadFixed32(); + break; + } + case 65: { + OptionalFixed64 = input.ReadFixed64(); + break; + } + case 77: { + OptionalSfixed32 = input.ReadSFixed32(); + break; + } + case 81: { + OptionalSfixed64 = input.ReadSFixed64(); + break; + } + case 93: { + OptionalFloat = input.ReadFloat(); + break; + } + case 97: { + OptionalDouble = input.ReadDouble(); + break; + } + case 104: { + OptionalBool = input.ReadBool(); + break; + } + case 114: { + OptionalString = input.ReadString(); + break; + } + case 122: { + OptionalBytes = input.ReadBytes(); + break; + } + case 131: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.CreateBuilder(); + if (HasOptionalGroup) { + subBuilder.MergeFrom(OptionalGroup); + } + input.ReadGroup(16, subBuilder, extensionRegistry); + OptionalGroup = subBuilder.BuildPartial(); + break; + } + case 146: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(); + if (HasOptionalNestedMessage) { + subBuilder.MergeFrom(OptionalNestedMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalNestedMessage = subBuilder.BuildPartial(); + break; + } + case 154: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + if (HasOptionalForeignMessage) { + subBuilder.MergeFrom(OptionalForeignMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalForeignMessage = subBuilder.BuildPartial(); + break; + } + case 162: { + global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ImportMessage.CreateBuilder(); + if (HasOptionalImportMessage) { + subBuilder.MergeFrom(OptionalImportMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalImportMessage = subBuilder.BuildPartial(); + break; + } + case 168: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum), rawValue)) { + unknownFields.MergeVarintField(21, (ulong) rawValue); + } else { + OptionalNestedEnum = (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum) rawValue; + } + break; + } + case 176: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(22, (ulong) rawValue); + } else { + OptionalForeignEnum = (global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue; + } + break; + } + case 184: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ImportEnum), rawValue)) { + unknownFields.MergeVarintField(23, (ulong) rawValue); + } else { + OptionalImportEnum = (global::Google.ProtocolBuffers.TestProtos.ImportEnum) rawValue; + } + break; + } + case 194: { + OptionalStringPiece = input.ReadString(); + break; + } + case 202: { + OptionalCord = input.ReadString(); + break; + } + case 248: { + AddRepeatedInt32(input.ReadInt32()); + break; + } + case 256: { + AddRepeatedInt64(input.ReadInt64()); + break; + } + case 264: { + AddRepeatedUint32(input.ReadUInt32()); + break; + } + case 272: { + AddRepeatedUint64(input.ReadUInt64()); + break; + } + case 280: { + AddRepeatedSint32(input.ReadSInt32()); + break; + } + case 288: { + AddRepeatedSint64(input.ReadSInt64()); + break; + } + case 301: { + AddRepeatedFixed32(input.ReadFixed32()); + break; + } + case 305: { + AddRepeatedFixed64(input.ReadFixed64()); + break; + } + case 317: { + AddRepeatedSfixed32(input.ReadSFixed32()); + break; + } + case 321: { + AddRepeatedSfixed64(input.ReadSFixed64()); + break; + } + case 333: { + AddRepeatedFloat(input.ReadFloat()); + break; + } + case 337: { + AddRepeatedDouble(input.ReadDouble()); + break; + } + case 344: { + AddRepeatedBool(input.ReadBool()); + break; + } + case 354: { + AddRepeatedString(input.ReadString()); + break; + } + case 362: { + AddRepeatedBytes(input.ReadBytes()); + break; + } + case 371: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.CreateBuilder(); + input.ReadGroup(46, subBuilder, extensionRegistry); + AddRepeatedGroup(subBuilder.BuildPartial()); + break; + } + case 386: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedNestedMessage(subBuilder.BuildPartial()); + break; + } + case 394: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedForeignMessage(subBuilder.BuildPartial()); + break; + } + case 402: { + global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ImportMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedImportMessage(subBuilder.BuildPartial()); + break; + } + case 408: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum), rawValue)) { + unknownFields.MergeVarintField(51, (ulong) rawValue); + } else { + AddRepeatedNestedEnum((global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum) rawValue); + } + break; + } + case 416: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(52, (ulong) rawValue); + } else { + AddRepeatedForeignEnum((global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue); + } + break; + } + case 424: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ImportEnum), rawValue)) { + unknownFields.MergeVarintField(53, (ulong) rawValue); + } else { + AddRepeatedImportEnum((global::Google.ProtocolBuffers.TestProtos.ImportEnum) rawValue); + } + break; + } + case 434: { + AddRepeatedStringPiece(input.ReadString()); + break; + } + case 442: { + AddRepeatedCord(input.ReadString()); + break; + } + case 488: { + DefaultInt32 = input.ReadInt32(); + break; + } + case 496: { + DefaultInt64 = input.ReadInt64(); + break; + } + case 504: { + DefaultUint32 = input.ReadUInt32(); + break; + } + case 512: { + DefaultUint64 = input.ReadUInt64(); + break; + } + case 520: { + DefaultSint32 = input.ReadSInt32(); + break; + } + case 528: { + DefaultSint64 = input.ReadSInt64(); + break; + } + case 541: { + DefaultFixed32 = input.ReadFixed32(); + break; + } + case 545: { + DefaultFixed64 = input.ReadFixed64(); + break; + } + case 557: { + DefaultSfixed32 = input.ReadSFixed32(); + break; + } + case 561: { + DefaultSfixed64 = input.ReadSFixed64(); + break; + } + case 573: { + DefaultFloat = input.ReadFloat(); + break; + } + case 577: { + DefaultDouble = input.ReadDouble(); + break; + } + case 584: { + DefaultBool = input.ReadBool(); + break; + } + case 594: { + DefaultString = input.ReadString(); + break; + } + case 602: { + DefaultBytes = input.ReadBytes(); + break; + } + case 648: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum), rawValue)) { + unknownFields.MergeVarintField(81, (ulong) rawValue); + } else { + DefaultNestedEnum = (global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum) rawValue; + } + break; + } + case 656: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(82, (ulong) rawValue); + } else { + DefaultForeignEnum = (global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue; + } + break; + } + case 664: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ImportEnum), rawValue)) { + unknownFields.MergeVarintField(83, (ulong) rawValue); + } else { + DefaultImportEnum = (global::Google.ProtocolBuffers.TestProtos.ImportEnum) rawValue; + } + break; + } + case 674: { + DefaultStringPiece = input.ReadString(); + break; + } + case 682: { + DefaultCord = input.ReadString(); + break; + } + } + } + } + + + public bool HasOptionalInt32 { + get { return result.HasOptionalInt32; } + } + public int OptionalInt32 { + get { return result.OptionalInt32; } + set { SetOptionalInt32(value); } + } + public Builder SetOptionalInt32(int value) { + result.hasOptionalInt32 = true; + result.optionalInt32_ = value; + return this; + } + public Builder ClearOptionalInt32() { + result.hasOptionalInt32 = false; + result.optionalInt32_ = 0; + return this; + } + + public bool HasOptionalInt64 { + get { return result.HasOptionalInt64; } + } + public long OptionalInt64 { + get { return result.OptionalInt64; } + set { SetOptionalInt64(value); } + } + public Builder SetOptionalInt64(long value) { + result.hasOptionalInt64 = true; + result.optionalInt64_ = value; + return this; + } + public Builder ClearOptionalInt64() { + result.hasOptionalInt64 = false; + result.optionalInt64_ = 0L; + return this; + } + + public bool HasOptionalUint32 { + get { return result.HasOptionalUint32; } + } + public uint OptionalUint32 { + get { return result.OptionalUint32; } + set { SetOptionalUint32(value); } + } + public Builder SetOptionalUint32(uint value) { + result.hasOptionalUint32 = true; + result.optionalUint32_ = value; + return this; + } + public Builder ClearOptionalUint32() { + result.hasOptionalUint32 = false; + result.optionalUint32_ = 0; + return this; + } + + public bool HasOptionalUint64 { + get { return result.HasOptionalUint64; } + } + public ulong OptionalUint64 { + get { return result.OptionalUint64; } + set { SetOptionalUint64(value); } + } + public Builder SetOptionalUint64(ulong value) { + result.hasOptionalUint64 = true; + result.optionalUint64_ = value; + return this; + } + public Builder ClearOptionalUint64() { + result.hasOptionalUint64 = false; + result.optionalUint64_ = 0UL; + return this; + } + + public bool HasOptionalSint32 { + get { return result.HasOptionalSint32; } + } + public int OptionalSint32 { + get { return result.OptionalSint32; } + set { SetOptionalSint32(value); } + } + public Builder SetOptionalSint32(int value) { + result.hasOptionalSint32 = true; + result.optionalSint32_ = value; + return this; + } + public Builder ClearOptionalSint32() { + result.hasOptionalSint32 = false; + result.optionalSint32_ = 0; + return this; + } + + public bool HasOptionalSint64 { + get { return result.HasOptionalSint64; } + } + public long OptionalSint64 { + get { return result.OptionalSint64; } + set { SetOptionalSint64(value); } + } + public Builder SetOptionalSint64(long value) { + result.hasOptionalSint64 = true; + result.optionalSint64_ = value; + return this; + } + public Builder ClearOptionalSint64() { + result.hasOptionalSint64 = false; + result.optionalSint64_ = 0; + return this; + } + + public bool HasOptionalFixed32 { + get { return result.HasOptionalFixed32; } + } + public uint OptionalFixed32 { + get { return result.OptionalFixed32; } + set { SetOptionalFixed32(value); } + } + public Builder SetOptionalFixed32(uint value) { + result.hasOptionalFixed32 = true; + result.optionalFixed32_ = value; + return this; + } + public Builder ClearOptionalFixed32() { + result.hasOptionalFixed32 = false; + result.optionalFixed32_ = 0; + return this; + } + + public bool HasOptionalFixed64 { + get { return result.HasOptionalFixed64; } + } + public ulong OptionalFixed64 { + get { return result.OptionalFixed64; } + set { SetOptionalFixed64(value); } + } + public Builder SetOptionalFixed64(ulong value) { + result.hasOptionalFixed64 = true; + result.optionalFixed64_ = value; + return this; + } + public Builder ClearOptionalFixed64() { + result.hasOptionalFixed64 = false; + result.optionalFixed64_ = 0; + return this; + } + + public bool HasOptionalSfixed32 { + get { return result.HasOptionalSfixed32; } + } + public int OptionalSfixed32 { + get { return result.OptionalSfixed32; } + set { SetOptionalSfixed32(value); } + } + public Builder SetOptionalSfixed32(int value) { + result.hasOptionalSfixed32 = true; + result.optionalSfixed32_ = value; + return this; + } + public Builder ClearOptionalSfixed32() { + result.hasOptionalSfixed32 = false; + result.optionalSfixed32_ = 0; + return this; + } + + public bool HasOptionalSfixed64 { + get { return result.HasOptionalSfixed64; } + } + public long OptionalSfixed64 { + get { return result.OptionalSfixed64; } + set { SetOptionalSfixed64(value); } + } + public Builder SetOptionalSfixed64(long value) { + result.hasOptionalSfixed64 = true; + result.optionalSfixed64_ = value; + return this; + } + public Builder ClearOptionalSfixed64() { + result.hasOptionalSfixed64 = false; + result.optionalSfixed64_ = 0; + return this; + } + + public bool HasOptionalFloat { + get { return result.HasOptionalFloat; } + } + public float OptionalFloat { + get { return result.OptionalFloat; } + set { SetOptionalFloat(value); } + } + public Builder SetOptionalFloat(float value) { + result.hasOptionalFloat = true; + result.optionalFloat_ = value; + return this; + } + public Builder ClearOptionalFloat() { + result.hasOptionalFloat = false; + result.optionalFloat_ = 0F; + return this; + } + + public bool HasOptionalDouble { + get { return result.HasOptionalDouble; } + } + public double OptionalDouble { + get { return result.OptionalDouble; } + set { SetOptionalDouble(value); } + } + public Builder SetOptionalDouble(double value) { + result.hasOptionalDouble = true; + result.optionalDouble_ = value; + return this; + } + public Builder ClearOptionalDouble() { + result.hasOptionalDouble = false; + result.optionalDouble_ = 0D; + return this; + } + + public bool HasOptionalBool { + get { return result.HasOptionalBool; } + } + public bool OptionalBool { + get { return result.OptionalBool; } + set { SetOptionalBool(value); } + } + public Builder SetOptionalBool(bool value) { + result.hasOptionalBool = true; + result.optionalBool_ = value; + return this; + } + public Builder ClearOptionalBool() { + result.hasOptionalBool = false; + result.optionalBool_ = false; + return this; + } + + public bool HasOptionalString { + get { return result.HasOptionalString; } + } + public string OptionalString { + get { return result.OptionalString; } + set { SetOptionalString(value); } + } + public Builder SetOptionalString(string value) { + result.hasOptionalString = true; + result.optionalString_ = value; + return this; + } + public Builder ClearOptionalString() { + result.hasOptionalString = false; + result.optionalString_ = ""; + return this; + } + + public bool HasOptionalBytes { + get { return result.HasOptionalBytes; } + } + public pb::ByteString OptionalBytes { + get { return result.OptionalBytes; } + set { SetOptionalBytes(value); } + } + public Builder SetOptionalBytes(pb::ByteString value) { + result.hasOptionalBytes = true; + result.optionalBytes_ = value; + return this; + } + public Builder ClearOptionalBytes() { + result.hasOptionalBytes = false; + result.optionalBytes_ = pb::ByteString.Empty; + return this; + } + + public bool HasOptionalGroup { + get { return result.HasOptionalGroup; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup OptionalGroup { + get { return result.OptionalGroup; } + set { SetOptionalGroup(value); } + } + public Builder SetOptionalGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup value) { + result.hasOptionalGroup = true; + result.optionalGroup_ = value; + return this; + } + public Builder SetOptionalGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.Builder builderForValue) { + result.hasOptionalGroup = true; + result.optionalGroup_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup value) { + if (result.HasOptionalGroup && + result.optionalGroup_ != global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.DefaultInstance) { + result.optionalGroup_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.CreateBuilder(result.optionalGroup_).MergeFrom(value).BuildPartial(); + } else { + result.optionalGroup_ = value; + } + result.hasOptionalGroup = true; + return this; + } + public Builder ClearOptionalGroup() { + result.hasOptionalGroup = false; + result.optionalGroup_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.OptionalGroup.DefaultInstance; + return this; + } + + public bool HasOptionalNestedMessage { + get { return result.HasOptionalNestedMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage OptionalNestedMessage { + get { return result.OptionalNestedMessage; } + set { SetOptionalNestedMessage(value); } + } + public Builder SetOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + result.hasOptionalNestedMessage = true; + result.optionalNestedMessage_ = value; + return this; + } + public Builder SetOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder builderForValue) { + result.hasOptionalNestedMessage = true; + result.optionalNestedMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + if (result.HasOptionalNestedMessage && + result.optionalNestedMessage_ != global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance) { + result.optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(result.optionalNestedMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalNestedMessage_ = value; + } + result.hasOptionalNestedMessage = true; + return this; + } + public Builder ClearOptionalNestedMessage() { + result.hasOptionalNestedMessage = false; + result.optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance; + return this; + } + + public bool HasOptionalForeignMessage { + get { return result.HasOptionalForeignMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage OptionalForeignMessage { + get { return result.OptionalForeignMessage; } + set { SetOptionalForeignMessage(value); } + } + public Builder SetOptionalForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.hasOptionalForeignMessage = true; + result.optionalForeignMessage_ = value; + return this; + } + public Builder SetOptionalForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.hasOptionalForeignMessage = true; + result.optionalForeignMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + if (result.HasOptionalForeignMessage && + result.optionalForeignMessage_ != global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance) { + result.optionalForeignMessage_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(result.optionalForeignMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalForeignMessage_ = value; + } + result.hasOptionalForeignMessage = true; + return this; + } + public Builder ClearOptionalForeignMessage() { + result.hasOptionalForeignMessage = false; + result.optionalForeignMessage_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + return this; + } + + public bool HasOptionalImportMessage { + get { return result.HasOptionalImportMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportMessage OptionalImportMessage { + get { return result.OptionalImportMessage; } + set { SetOptionalImportMessage(value); } + } + public Builder SetOptionalImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage value) { + result.hasOptionalImportMessage = true; + result.optionalImportMessage_ = value; + return this; + } + public Builder SetOptionalImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder builderForValue) { + result.hasOptionalImportMessage = true; + result.optionalImportMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage value) { + if (result.HasOptionalImportMessage && + result.optionalImportMessage_ != global::Google.ProtocolBuffers.TestProtos.ImportMessage.DefaultInstance) { + result.optionalImportMessage_ = global::Google.ProtocolBuffers.TestProtos.ImportMessage.CreateBuilder(result.optionalImportMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalImportMessage_ = value; + } + result.hasOptionalImportMessage = true; + return this; + } + public Builder ClearOptionalImportMessage() { + result.hasOptionalImportMessage = false; + result.optionalImportMessage_ = global::Google.ProtocolBuffers.TestProtos.ImportMessage.DefaultInstance; + return this; + } + + public bool HasOptionalNestedEnum { + get { return result.HasOptionalNestedEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum OptionalNestedEnum { + get { return result.OptionalNestedEnum; } + set { SetOptionalNestedEnum(value); } + } + public Builder SetOptionalNestedEnum(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum value) { + result.hasOptionalNestedEnum = true; + result.optionalNestedEnum_ = value; + return this; + } + public Builder ClearOptionalNestedEnum() { + result.hasOptionalNestedEnum = false; + result.optionalNestedEnum_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum.FOO; + return this; + } + + public bool HasOptionalForeignEnum { + get { return result.HasOptionalForeignEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum OptionalForeignEnum { + get { return result.OptionalForeignEnum; } + set { SetOptionalForeignEnum(value); } + } + public Builder SetOptionalForeignEnum(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.hasOptionalForeignEnum = true; + result.optionalForeignEnum_ = value; + return this; + } + public Builder ClearOptionalForeignEnum() { + result.hasOptionalForeignEnum = false; + result.optionalForeignEnum_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_FOO; + return this; + } + + public bool HasOptionalImportEnum { + get { return result.HasOptionalImportEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum OptionalImportEnum { + get { return result.OptionalImportEnum; } + set { SetOptionalImportEnum(value); } + } + public Builder SetOptionalImportEnum(global::Google.ProtocolBuffers.TestProtos.ImportEnum value) { + result.hasOptionalImportEnum = true; + result.optionalImportEnum_ = value; + return this; + } + public Builder ClearOptionalImportEnum() { + result.hasOptionalImportEnum = false; + result.optionalImportEnum_ = global::Google.ProtocolBuffers.TestProtos.ImportEnum.IMPORT_FOO; + return this; + } + + public bool HasOptionalStringPiece { + get { return result.HasOptionalStringPiece; } + } + public string OptionalStringPiece { + get { return result.OptionalStringPiece; } + set { SetOptionalStringPiece(value); } + } + public Builder SetOptionalStringPiece(string value) { + result.hasOptionalStringPiece = true; + result.optionalStringPiece_ = value; + return this; + } + public Builder ClearOptionalStringPiece() { + result.hasOptionalStringPiece = false; + result.optionalStringPiece_ = ""; + return this; + } + + public bool HasOptionalCord { + get { return result.HasOptionalCord; } + } + public string OptionalCord { + get { return result.OptionalCord; } + set { SetOptionalCord(value); } + } + public Builder SetOptionalCord(string value) { + result.hasOptionalCord = true; + result.optionalCord_ = value; + return this; + } + public Builder ClearOptionalCord() { + result.hasOptionalCord = false; + result.optionalCord_ = ""; + return this; + } + + public scg::IList<int> RepeatedInt32List { + get { return result.repeatedInt32_; } + } + public int RepeatedInt32Count { + get { return result.RepeatedInt32Count; } + } + public int GetRepeatedInt32(int index) { + return result.GetRepeatedInt32(index); + } + public Builder SetRepeatedInt32(int index, int value) { + result.repeatedInt32_[index] = value; + return this; + } + public Builder AddRepeatedInt32(int value) { + result.repeatedInt32_.Add(value); + return this; + } + public Builder AddRangeRepeatedInt32(scg::IEnumerable<int> values) { + base.AddRange(values, result.repeatedInt32_); + return this; + } + public Builder ClearRepeatedInt32() { + result.repeatedInt32_.Clear(); + return this; + } + + public scg::IList<long> RepeatedInt64List { + get { return result.repeatedInt64_; } + } + public int RepeatedInt64Count { + get { return result.RepeatedInt64Count; } + } + public long GetRepeatedInt64(int index) { + return result.GetRepeatedInt64(index); + } + public Builder SetRepeatedInt64(int index, long value) { + result.repeatedInt64_[index] = value; + return this; + } + public Builder AddRepeatedInt64(long value) { + result.repeatedInt64_.Add(value); + return this; + } + public Builder AddRangeRepeatedInt64(scg::IEnumerable<long> values) { + base.AddRange(values, result.repeatedInt64_); + return this; + } + public Builder ClearRepeatedInt64() { + result.repeatedInt64_.Clear(); + return this; + } + + public scg::IList<uint> RepeatedUint32List { + get { return result.repeatedUint32_; } + } + public int RepeatedUint32Count { + get { return result.RepeatedUint32Count; } + } + public uint GetRepeatedUint32(int index) { + return result.GetRepeatedUint32(index); + } + public Builder SetRepeatedUint32(int index, uint value) { + result.repeatedUint32_[index] = value; + return this; + } + public Builder AddRepeatedUint32(uint value) { + result.repeatedUint32_.Add(value); + return this; + } + public Builder AddRangeRepeatedUint32(scg::IEnumerable<uint> values) { + base.AddRange(values, result.repeatedUint32_); + return this; + } + public Builder ClearRepeatedUint32() { + result.repeatedUint32_.Clear(); + return this; + } + + public scg::IList<ulong> RepeatedUint64List { + get { return result.repeatedUint64_; } + } + public int RepeatedUint64Count { + get { return result.RepeatedUint64Count; } + } + public ulong GetRepeatedUint64(int index) { + return result.GetRepeatedUint64(index); + } + public Builder SetRepeatedUint64(int index, ulong value) { + result.repeatedUint64_[index] = value; + return this; + } + public Builder AddRepeatedUint64(ulong value) { + result.repeatedUint64_.Add(value); + return this; + } + public Builder AddRangeRepeatedUint64(scg::IEnumerable<ulong> values) { + base.AddRange(values, result.repeatedUint64_); + return this; + } + public Builder ClearRepeatedUint64() { + result.repeatedUint64_.Clear(); + return this; + } + + public scg::IList<int> RepeatedSint32List { + get { return result.repeatedSint32_; } + } + public int RepeatedSint32Count { + get { return result.RepeatedSint32Count; } + } + public int GetRepeatedSint32(int index) { + return result.GetRepeatedSint32(index); + } + public Builder SetRepeatedSint32(int index, int value) { + result.repeatedSint32_[index] = value; + return this; + } + public Builder AddRepeatedSint32(int value) { + result.repeatedSint32_.Add(value); + return this; + } + public Builder AddRangeRepeatedSint32(scg::IEnumerable<int> values) { + base.AddRange(values, result.repeatedSint32_); + return this; + } + public Builder ClearRepeatedSint32() { + result.repeatedSint32_.Clear(); + return this; + } + + public scg::IList<long> RepeatedSint64List { + get { return result.repeatedSint64_; } + } + public int RepeatedSint64Count { + get { return result.RepeatedSint64Count; } + } + public long GetRepeatedSint64(int index) { + return result.GetRepeatedSint64(index); + } + public Builder SetRepeatedSint64(int index, long value) { + result.repeatedSint64_[index] = value; + return this; + } + public Builder AddRepeatedSint64(long value) { + result.repeatedSint64_.Add(value); + return this; + } + public Builder AddRangeRepeatedSint64(scg::IEnumerable<long> values) { + base.AddRange(values, result.repeatedSint64_); + return this; + } + public Builder ClearRepeatedSint64() { + result.repeatedSint64_.Clear(); + return this; + } + + public scg::IList<uint> RepeatedFixed32List { + get { return result.repeatedFixed32_; } + } + public int RepeatedFixed32Count { + get { return result.RepeatedFixed32Count; } + } + public uint GetRepeatedFixed32(int index) { + return result.GetRepeatedFixed32(index); + } + public Builder SetRepeatedFixed32(int index, uint value) { + result.repeatedFixed32_[index] = value; + return this; + } + public Builder AddRepeatedFixed32(uint value) { + result.repeatedFixed32_.Add(value); + return this; + } + public Builder AddRangeRepeatedFixed32(scg::IEnumerable<uint> values) { + base.AddRange(values, result.repeatedFixed32_); + return this; + } + public Builder ClearRepeatedFixed32() { + result.repeatedFixed32_.Clear(); + return this; + } + + public scg::IList<ulong> RepeatedFixed64List { + get { return result.repeatedFixed64_; } + } + public int RepeatedFixed64Count { + get { return result.RepeatedFixed64Count; } + } + public ulong GetRepeatedFixed64(int index) { + return result.GetRepeatedFixed64(index); + } + public Builder SetRepeatedFixed64(int index, ulong value) { + result.repeatedFixed64_[index] = value; + return this; + } + public Builder AddRepeatedFixed64(ulong value) { + result.repeatedFixed64_.Add(value); + return this; + } + public Builder AddRangeRepeatedFixed64(scg::IEnumerable<ulong> values) { + base.AddRange(values, result.repeatedFixed64_); + return this; + } + public Builder ClearRepeatedFixed64() { + result.repeatedFixed64_.Clear(); + return this; + } + + public scg::IList<int> RepeatedSfixed32List { + get { return result.repeatedSfixed32_; } + } + public int RepeatedSfixed32Count { + get { return result.RepeatedSfixed32Count; } + } + public int GetRepeatedSfixed32(int index) { + return result.GetRepeatedSfixed32(index); + } + public Builder SetRepeatedSfixed32(int index, int value) { + result.repeatedSfixed32_[index] = value; + return this; + } + public Builder AddRepeatedSfixed32(int value) { + result.repeatedSfixed32_.Add(value); + return this; + } + public Builder AddRangeRepeatedSfixed32(scg::IEnumerable<int> values) { + base.AddRange(values, result.repeatedSfixed32_); + return this; + } + public Builder ClearRepeatedSfixed32() { + result.repeatedSfixed32_.Clear(); + return this; + } + + public scg::IList<long> RepeatedSfixed64List { + get { return result.repeatedSfixed64_; } + } + public int RepeatedSfixed64Count { + get { return result.RepeatedSfixed64Count; } + } + public long GetRepeatedSfixed64(int index) { + return result.GetRepeatedSfixed64(index); + } + public Builder SetRepeatedSfixed64(int index, long value) { + result.repeatedSfixed64_[index] = value; + return this; + } + public Builder AddRepeatedSfixed64(long value) { + result.repeatedSfixed64_.Add(value); + return this; + } + public Builder AddRangeRepeatedSfixed64(scg::IEnumerable<long> values) { + base.AddRange(values, result.repeatedSfixed64_); + return this; + } + public Builder ClearRepeatedSfixed64() { + result.repeatedSfixed64_.Clear(); + return this; + } + + public scg::IList<float> RepeatedFloatList { + get { return result.repeatedFloat_; } + } + public int RepeatedFloatCount { + get { return result.RepeatedFloatCount; } + } + public float GetRepeatedFloat(int index) { + return result.GetRepeatedFloat(index); + } + public Builder SetRepeatedFloat(int index, float value) { + result.repeatedFloat_[index] = value; + return this; + } + public Builder AddRepeatedFloat(float value) { + result.repeatedFloat_.Add(value); + return this; + } + public Builder AddRangeRepeatedFloat(scg::IEnumerable<float> values) { + base.AddRange(values, result.repeatedFloat_); + return this; + } + public Builder ClearRepeatedFloat() { + result.repeatedFloat_.Clear(); + return this; + } + + public scg::IList<double> RepeatedDoubleList { + get { return result.repeatedDouble_; } + } + public int RepeatedDoubleCount { + get { return result.RepeatedDoubleCount; } + } + public double GetRepeatedDouble(int index) { + return result.GetRepeatedDouble(index); + } + public Builder SetRepeatedDouble(int index, double value) { + result.repeatedDouble_[index] = value; + return this; + } + public Builder AddRepeatedDouble(double value) { + result.repeatedDouble_.Add(value); + return this; + } + public Builder AddRangeRepeatedDouble(scg::IEnumerable<double> values) { + base.AddRange(values, result.repeatedDouble_); + return this; + } + public Builder ClearRepeatedDouble() { + result.repeatedDouble_.Clear(); + return this; + } + + public scg::IList<bool> RepeatedBoolList { + get { return result.repeatedBool_; } + } + public int RepeatedBoolCount { + get { return result.RepeatedBoolCount; } + } + public bool GetRepeatedBool(int index) { + return result.GetRepeatedBool(index); + } + public Builder SetRepeatedBool(int index, bool value) { + result.repeatedBool_[index] = value; + return this; + } + public Builder AddRepeatedBool(bool value) { + result.repeatedBool_.Add(value); + return this; + } + public Builder AddRangeRepeatedBool(scg::IEnumerable<bool> values) { + base.AddRange(values, result.repeatedBool_); + return this; + } + public Builder ClearRepeatedBool() { + result.repeatedBool_.Clear(); + return this; + } + + public scg::IList<string> RepeatedStringList { + get { return result.repeatedString_; } + } + public int RepeatedStringCount { + get { return result.RepeatedStringCount; } + } + public string GetRepeatedString(int index) { + return result.GetRepeatedString(index); + } + public Builder SetRepeatedString(int index, string value) { + result.repeatedString_[index] = value; + return this; + } + public Builder AddRepeatedString(string value) { + result.repeatedString_.Add(value); + return this; + } + public Builder AddRangeRepeatedString(scg::IEnumerable<string> values) { + base.AddRange(values, result.repeatedString_); + return this; + } + public Builder ClearRepeatedString() { + result.repeatedString_.Clear(); + return this; + } + + public scg::IList<pb::ByteString> RepeatedBytesList { + get { return result.repeatedBytes_; } + } + public int RepeatedBytesCount { + get { return result.RepeatedBytesCount; } + } + public pb::ByteString GetRepeatedBytes(int index) { + return result.GetRepeatedBytes(index); + } + public Builder SetRepeatedBytes(int index, pb::ByteString value) { + result.repeatedBytes_[index] = value; + return this; + } + public Builder AddRepeatedBytes(pb::ByteString value) { + result.repeatedBytes_.Add(value); + return this; + } + public Builder AddRangeRepeatedBytes(scg::IEnumerable<pb::ByteString> values) { + base.AddRange(values, result.repeatedBytes_); + return this; + } + public Builder ClearRepeatedBytes() { + result.repeatedBytes_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup> RepeatedGroupList { + get { return result.repeatedGroup_; } + } + public int RepeatedGroupCount { + get { return result.RepeatedGroupCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup GetRepeatedGroup(int index) { + return result.GetRepeatedGroup(index); + } + public Builder SetRepeatedGroup(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup value) { + result.repeatedGroup_[index] = value; + return this; + } + public Builder SetRepeatedGroup(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.Builder builderForValue) { + result.repeatedGroup_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup value) { + result.repeatedGroup_.Add(value); + return this; + } + public Builder AddRepeatedGroup(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup.Builder builderForValue) { + result.repeatedGroup_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedGroup(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.RepeatedGroup> values) { + base.AddRange(values, result.repeatedGroup_); + return this; + } + public Builder ClearRepeatedGroup() { + result.repeatedGroup_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage> RepeatedNestedMessageList { + get { return result.repeatedNestedMessage_; } + } + public int RepeatedNestedMessageCount { + get { return result.RepeatedNestedMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage GetRepeatedNestedMessage(int index) { + return result.GetRepeatedNestedMessage(index); + } + public Builder SetRepeatedNestedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + result.repeatedNestedMessage_[index] = value; + return this; + } + public Builder SetRepeatedNestedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder builderForValue) { + result.repeatedNestedMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + result.repeatedNestedMessage_.Add(value); + return this; + } + public Builder AddRepeatedNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder builderForValue) { + result.repeatedNestedMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedNestedMessage(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage> values) { + base.AddRange(values, result.repeatedNestedMessage_); + return this; + } + public Builder ClearRepeatedNestedMessage() { + result.repeatedNestedMessage_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> RepeatedForeignMessageList { + get { return result.repeatedForeignMessage_; } + } + public int RepeatedForeignMessageCount { + get { return result.RepeatedForeignMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetRepeatedForeignMessage(int index) { + return result.GetRepeatedForeignMessage(index); + } + public Builder SetRepeatedForeignMessage(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.repeatedForeignMessage_[index] = value; + return this; + } + public Builder SetRepeatedForeignMessage(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.repeatedForeignMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.repeatedForeignMessage_.Add(value); + return this; + } + public Builder AddRepeatedForeignMessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.repeatedForeignMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedForeignMessage(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> values) { + base.AddRange(values, result.repeatedForeignMessage_); + return this; + } + public Builder ClearRepeatedForeignMessage() { + result.repeatedForeignMessage_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ImportMessage> RepeatedImportMessageList { + get { return result.repeatedImportMessage_; } + } + public int RepeatedImportMessageCount { + get { return result.RepeatedImportMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportMessage GetRepeatedImportMessage(int index) { + return result.GetRepeatedImportMessage(index); + } + public Builder SetRepeatedImportMessage(int index, global::Google.ProtocolBuffers.TestProtos.ImportMessage value) { + result.repeatedImportMessage_[index] = value; + return this; + } + public Builder SetRepeatedImportMessage(int index, global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder builderForValue) { + result.repeatedImportMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage value) { + result.repeatedImportMessage_.Add(value); + return this; + } + public Builder AddRepeatedImportMessage(global::Google.ProtocolBuffers.TestProtos.ImportMessage.Builder builderForValue) { + result.repeatedImportMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedImportMessage(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.ImportMessage> values) { + base.AddRange(values, result.repeatedImportMessage_); + return this; + } + public Builder ClearRepeatedImportMessage() { + result.repeatedImportMessage_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum> RepeatedNestedEnumList { + get { return result.repeatedNestedEnum_; } + } + public int RepeatedNestedEnumCount { + get { return result.RepeatedNestedEnumCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum GetRepeatedNestedEnum(int index) { + return result.GetRepeatedNestedEnum(index); + } + public Builder SetRepeatedNestedEnum(int index, global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum value) { + result.repeatedNestedEnum_[index] = value; + return this; + } + public Builder AddRepeatedNestedEnum(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum value) { + result.repeatedNestedEnum_.Add(value); + return this; + } + public Builder AddRangeRepeatedNestedEnum(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum> values) { + base.AddRange(values, result.repeatedNestedEnum_); + return this; + } + public Builder ClearRepeatedNestedEnum() { + result.repeatedNestedEnum_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> RepeatedForeignEnumList { + get { return result.repeatedForeignEnum_; } + } + public int RepeatedForeignEnumCount { + get { return result.RepeatedForeignEnumCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetRepeatedForeignEnum(int index) { + return result.GetRepeatedForeignEnum(index); + } + public Builder SetRepeatedForeignEnum(int index, global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.repeatedForeignEnum_[index] = value; + return this; + } + public Builder AddRepeatedForeignEnum(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.repeatedForeignEnum_.Add(value); + return this; + } + public Builder AddRangeRepeatedForeignEnum(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> values) { + base.AddRange(values, result.repeatedForeignEnum_); + return this; + } + public Builder ClearRepeatedForeignEnum() { + result.repeatedForeignEnum_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ImportEnum> RepeatedImportEnumList { + get { return result.repeatedImportEnum_; } + } + public int RepeatedImportEnumCount { + get { return result.RepeatedImportEnumCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum GetRepeatedImportEnum(int index) { + return result.GetRepeatedImportEnum(index); + } + public Builder SetRepeatedImportEnum(int index, global::Google.ProtocolBuffers.TestProtos.ImportEnum value) { + result.repeatedImportEnum_[index] = value; + return this; + } + public Builder AddRepeatedImportEnum(global::Google.ProtocolBuffers.TestProtos.ImportEnum value) { + result.repeatedImportEnum_.Add(value); + return this; + } + public Builder AddRangeRepeatedImportEnum(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.ImportEnum> values) { + base.AddRange(values, result.repeatedImportEnum_); + return this; + } + public Builder ClearRepeatedImportEnum() { + result.repeatedImportEnum_.Clear(); + return this; + } + + public scg::IList<string> RepeatedStringPieceList { + get { return result.repeatedStringPiece_; } + } + public int RepeatedStringPieceCount { + get { return result.RepeatedStringPieceCount; } + } + public string GetRepeatedStringPiece(int index) { + return result.GetRepeatedStringPiece(index); + } + public Builder SetRepeatedStringPiece(int index, string value) { + result.repeatedStringPiece_[index] = value; + return this; + } + public Builder AddRepeatedStringPiece(string value) { + result.repeatedStringPiece_.Add(value); + return this; + } + public Builder AddRangeRepeatedStringPiece(scg::IEnumerable<string> values) { + base.AddRange(values, result.repeatedStringPiece_); + return this; + } + public Builder ClearRepeatedStringPiece() { + result.repeatedStringPiece_.Clear(); + return this; + } + + public scg::IList<string> RepeatedCordList { + get { return result.repeatedCord_; } + } + public int RepeatedCordCount { + get { return result.RepeatedCordCount; } + } + public string GetRepeatedCord(int index) { + return result.GetRepeatedCord(index); + } + public Builder SetRepeatedCord(int index, string value) { + result.repeatedCord_[index] = value; + return this; + } + public Builder AddRepeatedCord(string value) { + result.repeatedCord_.Add(value); + return this; + } + public Builder AddRangeRepeatedCord(scg::IEnumerable<string> values) { + base.AddRange(values, result.repeatedCord_); + return this; + } + public Builder ClearRepeatedCord() { + result.repeatedCord_.Clear(); + return this; + } + + public bool HasDefaultInt32 { + get { return result.HasDefaultInt32; } + } + public int DefaultInt32 { + get { return result.DefaultInt32; } + set { SetDefaultInt32(value); } + } + public Builder SetDefaultInt32(int value) { + result.hasDefaultInt32 = true; + result.defaultInt32_ = value; + return this; + } + public Builder ClearDefaultInt32() { + result.hasDefaultInt32 = false; + result.defaultInt32_ = 41; + return this; + } + + public bool HasDefaultInt64 { + get { return result.HasDefaultInt64; } + } + public long DefaultInt64 { + get { return result.DefaultInt64; } + set { SetDefaultInt64(value); } + } + public Builder SetDefaultInt64(long value) { + result.hasDefaultInt64 = true; + result.defaultInt64_ = value; + return this; + } + public Builder ClearDefaultInt64() { + result.hasDefaultInt64 = false; + result.defaultInt64_ = 42L; + return this; + } + + public bool HasDefaultUint32 { + get { return result.HasDefaultUint32; } + } + public uint DefaultUint32 { + get { return result.DefaultUint32; } + set { SetDefaultUint32(value); } + } + public Builder SetDefaultUint32(uint value) { + result.hasDefaultUint32 = true; + result.defaultUint32_ = value; + return this; + } + public Builder ClearDefaultUint32() { + result.hasDefaultUint32 = false; + result.defaultUint32_ = 43; + return this; + } + + public bool HasDefaultUint64 { + get { return result.HasDefaultUint64; } + } + public ulong DefaultUint64 { + get { return result.DefaultUint64; } + set { SetDefaultUint64(value); } + } + public Builder SetDefaultUint64(ulong value) { + result.hasDefaultUint64 = true; + result.defaultUint64_ = value; + return this; + } + public Builder ClearDefaultUint64() { + result.hasDefaultUint64 = false; + result.defaultUint64_ = 44UL; + return this; + } + + public bool HasDefaultSint32 { + get { return result.HasDefaultSint32; } + } + public int DefaultSint32 { + get { return result.DefaultSint32; } + set { SetDefaultSint32(value); } + } + public Builder SetDefaultSint32(int value) { + result.hasDefaultSint32 = true; + result.defaultSint32_ = value; + return this; + } + public Builder ClearDefaultSint32() { + result.hasDefaultSint32 = false; + result.defaultSint32_ = -45; + return this; + } + + public bool HasDefaultSint64 { + get { return result.HasDefaultSint64; } + } + public long DefaultSint64 { + get { return result.DefaultSint64; } + set { SetDefaultSint64(value); } + } + public Builder SetDefaultSint64(long value) { + result.hasDefaultSint64 = true; + result.defaultSint64_ = value; + return this; + } + public Builder ClearDefaultSint64() { + result.hasDefaultSint64 = false; + result.defaultSint64_ = 46; + return this; + } + + public bool HasDefaultFixed32 { + get { return result.HasDefaultFixed32; } + } + public uint DefaultFixed32 { + get { return result.DefaultFixed32; } + set { SetDefaultFixed32(value); } + } + public Builder SetDefaultFixed32(uint value) { + result.hasDefaultFixed32 = true; + result.defaultFixed32_ = value; + return this; + } + public Builder ClearDefaultFixed32() { + result.hasDefaultFixed32 = false; + result.defaultFixed32_ = 47; + return this; + } + + public bool HasDefaultFixed64 { + get { return result.HasDefaultFixed64; } + } + public ulong DefaultFixed64 { + get { return result.DefaultFixed64; } + set { SetDefaultFixed64(value); } + } + public Builder SetDefaultFixed64(ulong value) { + result.hasDefaultFixed64 = true; + result.defaultFixed64_ = value; + return this; + } + public Builder ClearDefaultFixed64() { + result.hasDefaultFixed64 = false; + result.defaultFixed64_ = 48; + return this; + } + + public bool HasDefaultSfixed32 { + get { return result.HasDefaultSfixed32; } + } + public int DefaultSfixed32 { + get { return result.DefaultSfixed32; } + set { SetDefaultSfixed32(value); } + } + public Builder SetDefaultSfixed32(int value) { + result.hasDefaultSfixed32 = true; + result.defaultSfixed32_ = value; + return this; + } + public Builder ClearDefaultSfixed32() { + result.hasDefaultSfixed32 = false; + result.defaultSfixed32_ = 49; + return this; + } + + public bool HasDefaultSfixed64 { + get { return result.HasDefaultSfixed64; } + } + public long DefaultSfixed64 { + get { return result.DefaultSfixed64; } + set { SetDefaultSfixed64(value); } + } + public Builder SetDefaultSfixed64(long value) { + result.hasDefaultSfixed64 = true; + result.defaultSfixed64_ = value; + return this; + } + public Builder ClearDefaultSfixed64() { + result.hasDefaultSfixed64 = false; + result.defaultSfixed64_ = -50; + return this; + } + + public bool HasDefaultFloat { + get { return result.HasDefaultFloat; } + } + public float DefaultFloat { + get { return result.DefaultFloat; } + set { SetDefaultFloat(value); } + } + public Builder SetDefaultFloat(float value) { + result.hasDefaultFloat = true; + result.defaultFloat_ = value; + return this; + } + public Builder ClearDefaultFloat() { + result.hasDefaultFloat = false; + result.defaultFloat_ = 51.5F; + return this; + } + + public bool HasDefaultDouble { + get { return result.HasDefaultDouble; } + } + public double DefaultDouble { + get { return result.DefaultDouble; } + set { SetDefaultDouble(value); } + } + public Builder SetDefaultDouble(double value) { + result.hasDefaultDouble = true; + result.defaultDouble_ = value; + return this; + } + public Builder ClearDefaultDouble() { + result.hasDefaultDouble = false; + result.defaultDouble_ = 52000D; + return this; + } + + public bool HasDefaultBool { + get { return result.HasDefaultBool; } + } + public bool DefaultBool { + get { return result.DefaultBool; } + set { SetDefaultBool(value); } + } + public Builder SetDefaultBool(bool value) { + result.hasDefaultBool = true; + result.defaultBool_ = value; + return this; + } + public Builder ClearDefaultBool() { + result.hasDefaultBool = false; + result.defaultBool_ = true; + return this; + } + + public bool HasDefaultString { + get { return result.HasDefaultString; } + } + public string DefaultString { + get { return result.DefaultString; } + set { SetDefaultString(value); } + } + public Builder SetDefaultString(string value) { + result.hasDefaultString = true; + result.defaultString_ = value; + return this; + } + public Builder ClearDefaultString() { + result.hasDefaultString = false; + result.defaultString_ = "hello"; + return this; + } + + public bool HasDefaultBytes { + get { return result.HasDefaultBytes; } + } + public pb::ByteString DefaultBytes { + get { return result.DefaultBytes; } + set { SetDefaultBytes(value); } + } + public Builder SetDefaultBytes(pb::ByteString value) { + result.hasDefaultBytes = true; + result.defaultBytes_ = value; + return this; + } + public Builder ClearDefaultBytes() { + result.hasDefaultBytes = false; + result.defaultBytes_ = (pb::ByteString) global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Descriptor.Fields[62].DefaultValue; + return this; + } + + public bool HasDefaultNestedEnum { + get { return result.HasDefaultNestedEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum DefaultNestedEnum { + get { return result.DefaultNestedEnum; } + set { SetDefaultNestedEnum(value); } + } + public Builder SetDefaultNestedEnum(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum value) { + result.hasDefaultNestedEnum = true; + result.defaultNestedEnum_ = value; + return this; + } + public Builder ClearDefaultNestedEnum() { + result.hasDefaultNestedEnum = false; + result.defaultNestedEnum_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedEnum.BAR; + return this; + } + + public bool HasDefaultForeignEnum { + get { return result.HasDefaultForeignEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum DefaultForeignEnum { + get { return result.DefaultForeignEnum; } + set { SetDefaultForeignEnum(value); } + } + public Builder SetDefaultForeignEnum(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.hasDefaultForeignEnum = true; + result.defaultForeignEnum_ = value; + return this; + } + public Builder ClearDefaultForeignEnum() { + result.hasDefaultForeignEnum = false; + result.defaultForeignEnum_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_BAR; + return this; + } + + public bool HasDefaultImportEnum { + get { return result.HasDefaultImportEnum; } + } + public global::Google.ProtocolBuffers.TestProtos.ImportEnum DefaultImportEnum { + get { return result.DefaultImportEnum; } + set { SetDefaultImportEnum(value); } + } + public Builder SetDefaultImportEnum(global::Google.ProtocolBuffers.TestProtos.ImportEnum value) { + result.hasDefaultImportEnum = true; + result.defaultImportEnum_ = value; + return this; + } + public Builder ClearDefaultImportEnum() { + result.hasDefaultImportEnum = false; + result.defaultImportEnum_ = global::Google.ProtocolBuffers.TestProtos.ImportEnum.IMPORT_BAR; + return this; + } + + public bool HasDefaultStringPiece { + get { return result.HasDefaultStringPiece; } + } + public string DefaultStringPiece { + get { return result.DefaultStringPiece; } + set { SetDefaultStringPiece(value); } + } + public Builder SetDefaultStringPiece(string value) { + result.hasDefaultStringPiece = true; + result.defaultStringPiece_ = value; + return this; + } + public Builder ClearDefaultStringPiece() { + result.hasDefaultStringPiece = false; + result.defaultStringPiece_ = "abc"; + return this; + } + + public bool HasDefaultCord { + get { return result.HasDefaultCord; } + } + public string DefaultCord { + get { return result.DefaultCord; } + set { SetDefaultCord(value); } + } + public Builder SetDefaultCord(string value) { + result.hasDefaultCord = true; + result.defaultCord_ = value; + return this; + } + public Builder ClearDefaultCord() { + result.hasDefaultCord = false; + result.defaultCord_ = "123"; + return this; + } + } + } + + public sealed partial class ForeignMessage : pb::GeneratedMessage<ForeignMessage, ForeignMessage.Builder> { + private static readonly ForeignMessage defaultInstance = new Builder().BuildPartial(); + public static ForeignMessage DefaultInstance { + get { return defaultInstance; } + } + + public override ForeignMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ForeignMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_ForeignMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ForeignMessage, ForeignMessage.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_ForeignMessage__FieldAccessorTable; } + } + + private bool hasC; + private int c_ = 0; + public bool HasC { + get { return hasC; } + } + public int C { + get { return c_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasC) { + output.WriteInt32(1, C); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasC) { + size += pb::CodedOutputStream.ComputeInt32Size(1, C); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ForeignMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ForeignMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ForeignMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ForeignMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ForeignMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ForeignMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ForeignMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ForeignMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ForeignMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<ForeignMessage, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ForeignMessage result = new ForeignMessage(); + + protected override ForeignMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ForeignMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ForeignMessage.Descriptor; } + } + + public override ForeignMessage DefaultInstanceForType { + get { return ForeignMessage.DefaultInstance; } + } + + public override ForeignMessage BuildPartial() { + ForeignMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ForeignMessage) { + return MergeFrom((ForeignMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ForeignMessage other) { + if (other == ForeignMessage.DefaultInstance) return this; + if (other.HasC) { + C = other.C; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + C = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasC { + get { return result.HasC; } + } + public int C { + get { return result.C; } + set { SetC(value); } + } + public Builder SetC(int value) { + result.hasC = true; + result.c_ = value; + return this; + } + public Builder ClearC() { + result.hasC = false; + result.c_ = 0; + return this; + } + } + } + + public sealed partial class TestAllExtensions : pb::ExtendableMessage<TestAllExtensions, TestAllExtensions.Builder> { + private static readonly TestAllExtensions defaultInstance = new Builder().BuildPartial(); + public static TestAllExtensions DefaultInstance { + get { return defaultInstance; } + } + + public override TestAllExtensions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestAllExtensions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllExtensions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestAllExtensions, TestAllExtensions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestAllExtensions__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<TestAllExtensions, TestAllExtensions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestAllExtensions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestAllExtensions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestAllExtensions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<TestAllExtensions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestAllExtensions result = new TestAllExtensions(); + + protected override TestAllExtensions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestAllExtensions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestAllExtensions.Descriptor; } + } + + public override TestAllExtensions DefaultInstanceForType { + get { return TestAllExtensions.DefaultInstance; } + } + + public override TestAllExtensions BuildPartial() { + TestAllExtensions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestAllExtensions) { + return MergeFrom((TestAllExtensions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestAllExtensions other) { + if (other == TestAllExtensions.DefaultInstance) return this; + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class OptionalGroup_extension : pb::GeneratedMessage<OptionalGroup_extension, OptionalGroup_extension.Builder> { + private static readonly OptionalGroup_extension defaultInstance = new Builder().BuildPartial(); + public static OptionalGroup_extension DefaultInstance { + get { return defaultInstance; } + } + + public override OptionalGroup_extension DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override OptionalGroup_extension ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_OptionalGroup_extension__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<OptionalGroup_extension, OptionalGroup_extension.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_OptionalGroup_extension__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(17, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(17, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static OptionalGroup_extension ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static OptionalGroup_extension ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(OptionalGroup_extension prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<OptionalGroup_extension, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + OptionalGroup_extension result = new OptionalGroup_extension(); + + protected override OptionalGroup_extension MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new OptionalGroup_extension(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return OptionalGroup_extension.Descriptor; } + } + + public override OptionalGroup_extension DefaultInstanceForType { + get { return OptionalGroup_extension.DefaultInstance; } + } + + public override OptionalGroup_extension BuildPartial() { + OptionalGroup_extension returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is OptionalGroup_extension) { + return MergeFrom((OptionalGroup_extension) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(OptionalGroup_extension other) { + if (other == OptionalGroup_extension.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 136: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + public sealed partial class RepeatedGroup_extension : pb::GeneratedMessage<RepeatedGroup_extension, RepeatedGroup_extension.Builder> { + private static readonly RepeatedGroup_extension defaultInstance = new Builder().BuildPartial(); + public static RepeatedGroup_extension DefaultInstance { + get { return defaultInstance; } + } + + public override RepeatedGroup_extension DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override RepeatedGroup_extension ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_RepeatedGroup_extension__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<RepeatedGroup_extension, RepeatedGroup_extension.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_RepeatedGroup_extension__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(47, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(47, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static RepeatedGroup_extension ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static RepeatedGroup_extension ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(RepeatedGroup_extension prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<RepeatedGroup_extension, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + RepeatedGroup_extension result = new RepeatedGroup_extension(); + + protected override RepeatedGroup_extension MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new RepeatedGroup_extension(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return RepeatedGroup_extension.Descriptor; } + } + + public override RepeatedGroup_extension DefaultInstanceForType { + get { return RepeatedGroup_extension.DefaultInstance; } + } + + public override RepeatedGroup_extension BuildPartial() { + RepeatedGroup_extension returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is RepeatedGroup_extension) { + return MergeFrom((RepeatedGroup_extension) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(RepeatedGroup_extension other) { + if (other == RepeatedGroup_extension.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 376: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + public sealed partial class TestRequired : pb::GeneratedMessage<TestRequired, TestRequired.Builder> { + private static readonly TestRequired defaultInstance = new Builder().BuildPartial(); + public static TestRequired DefaultInstance { + get { return defaultInstance; } + } + + public override TestRequired DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestRequired ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRequired__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestRequired, TestRequired.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRequired__FieldAccessorTable; } + } + + public static readonly pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.TestRequired> Single = + pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.TestRequired>.CreateInstance(Descriptor.Extensions[0]); + public static readonly + pb::GeneratedExtensionBase<scg::IList<global::Google.ProtocolBuffers.TestProtos.TestRequired>> Multi = + pb::GeneratedRepeatExtension<global::Google.ProtocolBuffers.TestProtos.TestRequired>.CreateInstance(Descriptor.Extensions[1]); + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + private bool hasDummy2; + private int dummy2_ = 0; + public bool HasDummy2 { + get { return hasDummy2; } + } + public int Dummy2 { + get { return dummy2_; } + } + + private bool hasB; + private int b_ = 0; + public bool HasB { + get { return hasB; } + } + public int B { + get { return b_; } + } + + private bool hasDummy4; + private int dummy4_ = 0; + public bool HasDummy4 { + get { return hasDummy4; } + } + public int Dummy4 { + get { return dummy4_; } + } + + private bool hasDummy5; + private int dummy5_ = 0; + public bool HasDummy5 { + get { return hasDummy5; } + } + public int Dummy5 { + get { return dummy5_; } + } + + private bool hasDummy6; + private int dummy6_ = 0; + public bool HasDummy6 { + get { return hasDummy6; } + } + public int Dummy6 { + get { return dummy6_; } + } + + private bool hasDummy7; + private int dummy7_ = 0; + public bool HasDummy7 { + get { return hasDummy7; } + } + public int Dummy7 { + get { return dummy7_; } + } + + private bool hasDummy8; + private int dummy8_ = 0; + public bool HasDummy8 { + get { return hasDummy8; } + } + public int Dummy8 { + get { return dummy8_; } + } + + private bool hasDummy9; + private int dummy9_ = 0; + public bool HasDummy9 { + get { return hasDummy9; } + } + public int Dummy9 { + get { return dummy9_; } + } + + private bool hasDummy10; + private int dummy10_ = 0; + public bool HasDummy10 { + get { return hasDummy10; } + } + public int Dummy10 { + get { return dummy10_; } + } + + private bool hasDummy11; + private int dummy11_ = 0; + public bool HasDummy11 { + get { return hasDummy11; } + } + public int Dummy11 { + get { return dummy11_; } + } + + private bool hasDummy12; + private int dummy12_ = 0; + public bool HasDummy12 { + get { return hasDummy12; } + } + public int Dummy12 { + get { return dummy12_; } + } + + private bool hasDummy13; + private int dummy13_ = 0; + public bool HasDummy13 { + get { return hasDummy13; } + } + public int Dummy13 { + get { return dummy13_; } + } + + private bool hasDummy14; + private int dummy14_ = 0; + public bool HasDummy14 { + get { return hasDummy14; } + } + public int Dummy14 { + get { return dummy14_; } + } + + private bool hasDummy15; + private int dummy15_ = 0; + public bool HasDummy15 { + get { return hasDummy15; } + } + public int Dummy15 { + get { return dummy15_; } + } + + private bool hasDummy16; + private int dummy16_ = 0; + public bool HasDummy16 { + get { return hasDummy16; } + } + public int Dummy16 { + get { return dummy16_; } + } + + private bool hasDummy17; + private int dummy17_ = 0; + public bool HasDummy17 { + get { return hasDummy17; } + } + public int Dummy17 { + get { return dummy17_; } + } + + private bool hasDummy18; + private int dummy18_ = 0; + public bool HasDummy18 { + get { return hasDummy18; } + } + public int Dummy18 { + get { return dummy18_; } + } + + private bool hasDummy19; + private int dummy19_ = 0; + public bool HasDummy19 { + get { return hasDummy19; } + } + public int Dummy19 { + get { return dummy19_; } + } + + private bool hasDummy20; + private int dummy20_ = 0; + public bool HasDummy20 { + get { return hasDummy20; } + } + public int Dummy20 { + get { return dummy20_; } + } + + private bool hasDummy21; + private int dummy21_ = 0; + public bool HasDummy21 { + get { return hasDummy21; } + } + public int Dummy21 { + get { return dummy21_; } + } + + private bool hasDummy22; + private int dummy22_ = 0; + public bool HasDummy22 { + get { return hasDummy22; } + } + public int Dummy22 { + get { return dummy22_; } + } + + private bool hasDummy23; + private int dummy23_ = 0; + public bool HasDummy23 { + get { return hasDummy23; } + } + public int Dummy23 { + get { return dummy23_; } + } + + private bool hasDummy24; + private int dummy24_ = 0; + public bool HasDummy24 { + get { return hasDummy24; } + } + public int Dummy24 { + get { return dummy24_; } + } + + private bool hasDummy25; + private int dummy25_ = 0; + public bool HasDummy25 { + get { return hasDummy25; } + } + public int Dummy25 { + get { return dummy25_; } + } + + private bool hasDummy26; + private int dummy26_ = 0; + public bool HasDummy26 { + get { return hasDummy26; } + } + public int Dummy26 { + get { return dummy26_; } + } + + private bool hasDummy27; + private int dummy27_ = 0; + public bool HasDummy27 { + get { return hasDummy27; } + } + public int Dummy27 { + get { return dummy27_; } + } + + private bool hasDummy28; + private int dummy28_ = 0; + public bool HasDummy28 { + get { return hasDummy28; } + } + public int Dummy28 { + get { return dummy28_; } + } + + private bool hasDummy29; + private int dummy29_ = 0; + public bool HasDummy29 { + get { return hasDummy29; } + } + public int Dummy29 { + get { return dummy29_; } + } + + private bool hasDummy30; + private int dummy30_ = 0; + public bool HasDummy30 { + get { return hasDummy30; } + } + public int Dummy30 { + get { return dummy30_; } + } + + private bool hasDummy31; + private int dummy31_ = 0; + public bool HasDummy31 { + get { return hasDummy31; } + } + public int Dummy31 { + get { return dummy31_; } + } + + private bool hasDummy32; + private int dummy32_ = 0; + public bool HasDummy32 { + get { return hasDummy32; } + } + public int Dummy32 { + get { return dummy32_; } + } + + private bool hasC; + private int c_ = 0; + public bool HasC { + get { return hasC; } + } + public int C { + get { return c_; } + } + + public override bool IsInitialized { + get { + if (!hasA) return false; + if (!hasB) return false; + if (!hasC) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + if (HasDummy2) { + output.WriteInt32(2, Dummy2); + } + if (HasB) { + output.WriteInt32(3, B); + } + if (HasDummy4) { + output.WriteInt32(4, Dummy4); + } + if (HasDummy5) { + output.WriteInt32(5, Dummy5); + } + if (HasDummy6) { + output.WriteInt32(6, Dummy6); + } + if (HasDummy7) { + output.WriteInt32(7, Dummy7); + } + if (HasDummy8) { + output.WriteInt32(8, Dummy8); + } + if (HasDummy9) { + output.WriteInt32(9, Dummy9); + } + if (HasDummy10) { + output.WriteInt32(10, Dummy10); + } + if (HasDummy11) { + output.WriteInt32(11, Dummy11); + } + if (HasDummy12) { + output.WriteInt32(12, Dummy12); + } + if (HasDummy13) { + output.WriteInt32(13, Dummy13); + } + if (HasDummy14) { + output.WriteInt32(14, Dummy14); + } + if (HasDummy15) { + output.WriteInt32(15, Dummy15); + } + if (HasDummy16) { + output.WriteInt32(16, Dummy16); + } + if (HasDummy17) { + output.WriteInt32(17, Dummy17); + } + if (HasDummy18) { + output.WriteInt32(18, Dummy18); + } + if (HasDummy19) { + output.WriteInt32(19, Dummy19); + } + if (HasDummy20) { + output.WriteInt32(20, Dummy20); + } + if (HasDummy21) { + output.WriteInt32(21, Dummy21); + } + if (HasDummy22) { + output.WriteInt32(22, Dummy22); + } + if (HasDummy23) { + output.WriteInt32(23, Dummy23); + } + if (HasDummy24) { + output.WriteInt32(24, Dummy24); + } + if (HasDummy25) { + output.WriteInt32(25, Dummy25); + } + if (HasDummy26) { + output.WriteInt32(26, Dummy26); + } + if (HasDummy27) { + output.WriteInt32(27, Dummy27); + } + if (HasDummy28) { + output.WriteInt32(28, Dummy28); + } + if (HasDummy29) { + output.WriteInt32(29, Dummy29); + } + if (HasDummy30) { + output.WriteInt32(30, Dummy30); + } + if (HasDummy31) { + output.WriteInt32(31, Dummy31); + } + if (HasDummy32) { + output.WriteInt32(32, Dummy32); + } + if (HasC) { + output.WriteInt32(33, C); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + if (HasDummy2) { + size += pb::CodedOutputStream.ComputeInt32Size(2, Dummy2); + } + if (HasB) { + size += pb::CodedOutputStream.ComputeInt32Size(3, B); + } + if (HasDummy4) { + size += pb::CodedOutputStream.ComputeInt32Size(4, Dummy4); + } + if (HasDummy5) { + size += pb::CodedOutputStream.ComputeInt32Size(5, Dummy5); + } + if (HasDummy6) { + size += pb::CodedOutputStream.ComputeInt32Size(6, Dummy6); + } + if (HasDummy7) { + size += pb::CodedOutputStream.ComputeInt32Size(7, Dummy7); + } + if (HasDummy8) { + size += pb::CodedOutputStream.ComputeInt32Size(8, Dummy8); + } + if (HasDummy9) { + size += pb::CodedOutputStream.ComputeInt32Size(9, Dummy9); + } + if (HasDummy10) { + size += pb::CodedOutputStream.ComputeInt32Size(10, Dummy10); + } + if (HasDummy11) { + size += pb::CodedOutputStream.ComputeInt32Size(11, Dummy11); + } + if (HasDummy12) { + size += pb::CodedOutputStream.ComputeInt32Size(12, Dummy12); + } + if (HasDummy13) { + size += pb::CodedOutputStream.ComputeInt32Size(13, Dummy13); + } + if (HasDummy14) { + size += pb::CodedOutputStream.ComputeInt32Size(14, Dummy14); + } + if (HasDummy15) { + size += pb::CodedOutputStream.ComputeInt32Size(15, Dummy15); + } + if (HasDummy16) { + size += pb::CodedOutputStream.ComputeInt32Size(16, Dummy16); + } + if (HasDummy17) { + size += pb::CodedOutputStream.ComputeInt32Size(17, Dummy17); + } + if (HasDummy18) { + size += pb::CodedOutputStream.ComputeInt32Size(18, Dummy18); + } + if (HasDummy19) { + size += pb::CodedOutputStream.ComputeInt32Size(19, Dummy19); + } + if (HasDummy20) { + size += pb::CodedOutputStream.ComputeInt32Size(20, Dummy20); + } + if (HasDummy21) { + size += pb::CodedOutputStream.ComputeInt32Size(21, Dummy21); + } + if (HasDummy22) { + size += pb::CodedOutputStream.ComputeInt32Size(22, Dummy22); + } + if (HasDummy23) { + size += pb::CodedOutputStream.ComputeInt32Size(23, Dummy23); + } + if (HasDummy24) { + size += pb::CodedOutputStream.ComputeInt32Size(24, Dummy24); + } + if (HasDummy25) { + size += pb::CodedOutputStream.ComputeInt32Size(25, Dummy25); + } + if (HasDummy26) { + size += pb::CodedOutputStream.ComputeInt32Size(26, Dummy26); + } + if (HasDummy27) { + size += pb::CodedOutputStream.ComputeInt32Size(27, Dummy27); + } + if (HasDummy28) { + size += pb::CodedOutputStream.ComputeInt32Size(28, Dummy28); + } + if (HasDummy29) { + size += pb::CodedOutputStream.ComputeInt32Size(29, Dummy29); + } + if (HasDummy30) { + size += pb::CodedOutputStream.ComputeInt32Size(30, Dummy30); + } + if (HasDummy31) { + size += pb::CodedOutputStream.ComputeInt32Size(31, Dummy31); + } + if (HasDummy32) { + size += pb::CodedOutputStream.ComputeInt32Size(32, Dummy32); + } + if (HasC) { + size += pb::CodedOutputStream.ComputeInt32Size(33, C); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestRequired ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequired ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequired ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequired ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequired ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequired ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestRequired ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequired ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestRequired prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestRequired, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestRequired result = new TestRequired(); + + protected override TestRequired MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestRequired(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestRequired.Descriptor; } + } + + public override TestRequired DefaultInstanceForType { + get { return TestRequired.DefaultInstance; } + } + + public override TestRequired BuildPartial() { + TestRequired returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestRequired) { + return MergeFrom((TestRequired) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestRequired other) { + if (other == TestRequired.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + if (other.HasDummy2) { + Dummy2 = other.Dummy2; + } + if (other.HasB) { + B = other.B; + } + if (other.HasDummy4) { + Dummy4 = other.Dummy4; + } + if (other.HasDummy5) { + Dummy5 = other.Dummy5; + } + if (other.HasDummy6) { + Dummy6 = other.Dummy6; + } + if (other.HasDummy7) { + Dummy7 = other.Dummy7; + } + if (other.HasDummy8) { + Dummy8 = other.Dummy8; + } + if (other.HasDummy9) { + Dummy9 = other.Dummy9; + } + if (other.HasDummy10) { + Dummy10 = other.Dummy10; + } + if (other.HasDummy11) { + Dummy11 = other.Dummy11; + } + if (other.HasDummy12) { + Dummy12 = other.Dummy12; + } + if (other.HasDummy13) { + Dummy13 = other.Dummy13; + } + if (other.HasDummy14) { + Dummy14 = other.Dummy14; + } + if (other.HasDummy15) { + Dummy15 = other.Dummy15; + } + if (other.HasDummy16) { + Dummy16 = other.Dummy16; + } + if (other.HasDummy17) { + Dummy17 = other.Dummy17; + } + if (other.HasDummy18) { + Dummy18 = other.Dummy18; + } + if (other.HasDummy19) { + Dummy19 = other.Dummy19; + } + if (other.HasDummy20) { + Dummy20 = other.Dummy20; + } + if (other.HasDummy21) { + Dummy21 = other.Dummy21; + } + if (other.HasDummy22) { + Dummy22 = other.Dummy22; + } + if (other.HasDummy23) { + Dummy23 = other.Dummy23; + } + if (other.HasDummy24) { + Dummy24 = other.Dummy24; + } + if (other.HasDummy25) { + Dummy25 = other.Dummy25; + } + if (other.HasDummy26) { + Dummy26 = other.Dummy26; + } + if (other.HasDummy27) { + Dummy27 = other.Dummy27; + } + if (other.HasDummy28) { + Dummy28 = other.Dummy28; + } + if (other.HasDummy29) { + Dummy29 = other.Dummy29; + } + if (other.HasDummy30) { + Dummy30 = other.Dummy30; + } + if (other.HasDummy31) { + Dummy31 = other.Dummy31; + } + if (other.HasDummy32) { + Dummy32 = other.Dummy32; + } + if (other.HasC) { + C = other.C; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + case 16: { + Dummy2 = input.ReadInt32(); + break; + } + case 24: { + B = input.ReadInt32(); + break; + } + case 32: { + Dummy4 = input.ReadInt32(); + break; + } + case 40: { + Dummy5 = input.ReadInt32(); + break; + } + case 48: { + Dummy6 = input.ReadInt32(); + break; + } + case 56: { + Dummy7 = input.ReadInt32(); + break; + } + case 64: { + Dummy8 = input.ReadInt32(); + break; + } + case 72: { + Dummy9 = input.ReadInt32(); + break; + } + case 80: { + Dummy10 = input.ReadInt32(); + break; + } + case 88: { + Dummy11 = input.ReadInt32(); + break; + } + case 96: { + Dummy12 = input.ReadInt32(); + break; + } + case 104: { + Dummy13 = input.ReadInt32(); + break; + } + case 112: { + Dummy14 = input.ReadInt32(); + break; + } + case 120: { + Dummy15 = input.ReadInt32(); + break; + } + case 128: { + Dummy16 = input.ReadInt32(); + break; + } + case 136: { + Dummy17 = input.ReadInt32(); + break; + } + case 144: { + Dummy18 = input.ReadInt32(); + break; + } + case 152: { + Dummy19 = input.ReadInt32(); + break; + } + case 160: { + Dummy20 = input.ReadInt32(); + break; + } + case 168: { + Dummy21 = input.ReadInt32(); + break; + } + case 176: { + Dummy22 = input.ReadInt32(); + break; + } + case 184: { + Dummy23 = input.ReadInt32(); + break; + } + case 192: { + Dummy24 = input.ReadInt32(); + break; + } + case 200: { + Dummy25 = input.ReadInt32(); + break; + } + case 208: { + Dummy26 = input.ReadInt32(); + break; + } + case 216: { + Dummy27 = input.ReadInt32(); + break; + } + case 224: { + Dummy28 = input.ReadInt32(); + break; + } + case 232: { + Dummy29 = input.ReadInt32(); + break; + } + case 240: { + Dummy30 = input.ReadInt32(); + break; + } + case 248: { + Dummy31 = input.ReadInt32(); + break; + } + case 256: { + Dummy32 = input.ReadInt32(); + break; + } + case 264: { + C = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + + public bool HasDummy2 { + get { return result.HasDummy2; } + } + public int Dummy2 { + get { return result.Dummy2; } + set { SetDummy2(value); } + } + public Builder SetDummy2(int value) { + result.hasDummy2 = true; + result.dummy2_ = value; + return this; + } + public Builder ClearDummy2() { + result.hasDummy2 = false; + result.dummy2_ = 0; + return this; + } + + public bool HasB { + get { return result.HasB; } + } + public int B { + get { return result.B; } + set { SetB(value); } + } + public Builder SetB(int value) { + result.hasB = true; + result.b_ = value; + return this; + } + public Builder ClearB() { + result.hasB = false; + result.b_ = 0; + return this; + } + + public bool HasDummy4 { + get { return result.HasDummy4; } + } + public int Dummy4 { + get { return result.Dummy4; } + set { SetDummy4(value); } + } + public Builder SetDummy4(int value) { + result.hasDummy4 = true; + result.dummy4_ = value; + return this; + } + public Builder ClearDummy4() { + result.hasDummy4 = false; + result.dummy4_ = 0; + return this; + } + + public bool HasDummy5 { + get { return result.HasDummy5; } + } + public int Dummy5 { + get { return result.Dummy5; } + set { SetDummy5(value); } + } + public Builder SetDummy5(int value) { + result.hasDummy5 = true; + result.dummy5_ = value; + return this; + } + public Builder ClearDummy5() { + result.hasDummy5 = false; + result.dummy5_ = 0; + return this; + } + + public bool HasDummy6 { + get { return result.HasDummy6; } + } + public int Dummy6 { + get { return result.Dummy6; } + set { SetDummy6(value); } + } + public Builder SetDummy6(int value) { + result.hasDummy6 = true; + result.dummy6_ = value; + return this; + } + public Builder ClearDummy6() { + result.hasDummy6 = false; + result.dummy6_ = 0; + return this; + } + + public bool HasDummy7 { + get { return result.HasDummy7; } + } + public int Dummy7 { + get { return result.Dummy7; } + set { SetDummy7(value); } + } + public Builder SetDummy7(int value) { + result.hasDummy7 = true; + result.dummy7_ = value; + return this; + } + public Builder ClearDummy7() { + result.hasDummy7 = false; + result.dummy7_ = 0; + return this; + } + + public bool HasDummy8 { + get { return result.HasDummy8; } + } + public int Dummy8 { + get { return result.Dummy8; } + set { SetDummy8(value); } + } + public Builder SetDummy8(int value) { + result.hasDummy8 = true; + result.dummy8_ = value; + return this; + } + public Builder ClearDummy8() { + result.hasDummy8 = false; + result.dummy8_ = 0; + return this; + } + + public bool HasDummy9 { + get { return result.HasDummy9; } + } + public int Dummy9 { + get { return result.Dummy9; } + set { SetDummy9(value); } + } + public Builder SetDummy9(int value) { + result.hasDummy9 = true; + result.dummy9_ = value; + return this; + } + public Builder ClearDummy9() { + result.hasDummy9 = false; + result.dummy9_ = 0; + return this; + } + + public bool HasDummy10 { + get { return result.HasDummy10; } + } + public int Dummy10 { + get { return result.Dummy10; } + set { SetDummy10(value); } + } + public Builder SetDummy10(int value) { + result.hasDummy10 = true; + result.dummy10_ = value; + return this; + } + public Builder ClearDummy10() { + result.hasDummy10 = false; + result.dummy10_ = 0; + return this; + } + + public bool HasDummy11 { + get { return result.HasDummy11; } + } + public int Dummy11 { + get { return result.Dummy11; } + set { SetDummy11(value); } + } + public Builder SetDummy11(int value) { + result.hasDummy11 = true; + result.dummy11_ = value; + return this; + } + public Builder ClearDummy11() { + result.hasDummy11 = false; + result.dummy11_ = 0; + return this; + } + + public bool HasDummy12 { + get { return result.HasDummy12; } + } + public int Dummy12 { + get { return result.Dummy12; } + set { SetDummy12(value); } + } + public Builder SetDummy12(int value) { + result.hasDummy12 = true; + result.dummy12_ = value; + return this; + } + public Builder ClearDummy12() { + result.hasDummy12 = false; + result.dummy12_ = 0; + return this; + } + + public bool HasDummy13 { + get { return result.HasDummy13; } + } + public int Dummy13 { + get { return result.Dummy13; } + set { SetDummy13(value); } + } + public Builder SetDummy13(int value) { + result.hasDummy13 = true; + result.dummy13_ = value; + return this; + } + public Builder ClearDummy13() { + result.hasDummy13 = false; + result.dummy13_ = 0; + return this; + } + + public bool HasDummy14 { + get { return result.HasDummy14; } + } + public int Dummy14 { + get { return result.Dummy14; } + set { SetDummy14(value); } + } + public Builder SetDummy14(int value) { + result.hasDummy14 = true; + result.dummy14_ = value; + return this; + } + public Builder ClearDummy14() { + result.hasDummy14 = false; + result.dummy14_ = 0; + return this; + } + + public bool HasDummy15 { + get { return result.HasDummy15; } + } + public int Dummy15 { + get { return result.Dummy15; } + set { SetDummy15(value); } + } + public Builder SetDummy15(int value) { + result.hasDummy15 = true; + result.dummy15_ = value; + return this; + } + public Builder ClearDummy15() { + result.hasDummy15 = false; + result.dummy15_ = 0; + return this; + } + + public bool HasDummy16 { + get { return result.HasDummy16; } + } + public int Dummy16 { + get { return result.Dummy16; } + set { SetDummy16(value); } + } + public Builder SetDummy16(int value) { + result.hasDummy16 = true; + result.dummy16_ = value; + return this; + } + public Builder ClearDummy16() { + result.hasDummy16 = false; + result.dummy16_ = 0; + return this; + } + + public bool HasDummy17 { + get { return result.HasDummy17; } + } + public int Dummy17 { + get { return result.Dummy17; } + set { SetDummy17(value); } + } + public Builder SetDummy17(int value) { + result.hasDummy17 = true; + result.dummy17_ = value; + return this; + } + public Builder ClearDummy17() { + result.hasDummy17 = false; + result.dummy17_ = 0; + return this; + } + + public bool HasDummy18 { + get { return result.HasDummy18; } + } + public int Dummy18 { + get { return result.Dummy18; } + set { SetDummy18(value); } + } + public Builder SetDummy18(int value) { + result.hasDummy18 = true; + result.dummy18_ = value; + return this; + } + public Builder ClearDummy18() { + result.hasDummy18 = false; + result.dummy18_ = 0; + return this; + } + + public bool HasDummy19 { + get { return result.HasDummy19; } + } + public int Dummy19 { + get { return result.Dummy19; } + set { SetDummy19(value); } + } + public Builder SetDummy19(int value) { + result.hasDummy19 = true; + result.dummy19_ = value; + return this; + } + public Builder ClearDummy19() { + result.hasDummy19 = false; + result.dummy19_ = 0; + return this; + } + + public bool HasDummy20 { + get { return result.HasDummy20; } + } + public int Dummy20 { + get { return result.Dummy20; } + set { SetDummy20(value); } + } + public Builder SetDummy20(int value) { + result.hasDummy20 = true; + result.dummy20_ = value; + return this; + } + public Builder ClearDummy20() { + result.hasDummy20 = false; + result.dummy20_ = 0; + return this; + } + + public bool HasDummy21 { + get { return result.HasDummy21; } + } + public int Dummy21 { + get { return result.Dummy21; } + set { SetDummy21(value); } + } + public Builder SetDummy21(int value) { + result.hasDummy21 = true; + result.dummy21_ = value; + return this; + } + public Builder ClearDummy21() { + result.hasDummy21 = false; + result.dummy21_ = 0; + return this; + } + + public bool HasDummy22 { + get { return result.HasDummy22; } + } + public int Dummy22 { + get { return result.Dummy22; } + set { SetDummy22(value); } + } + public Builder SetDummy22(int value) { + result.hasDummy22 = true; + result.dummy22_ = value; + return this; + } + public Builder ClearDummy22() { + result.hasDummy22 = false; + result.dummy22_ = 0; + return this; + } + + public bool HasDummy23 { + get { return result.HasDummy23; } + } + public int Dummy23 { + get { return result.Dummy23; } + set { SetDummy23(value); } + } + public Builder SetDummy23(int value) { + result.hasDummy23 = true; + result.dummy23_ = value; + return this; + } + public Builder ClearDummy23() { + result.hasDummy23 = false; + result.dummy23_ = 0; + return this; + } + + public bool HasDummy24 { + get { return result.HasDummy24; } + } + public int Dummy24 { + get { return result.Dummy24; } + set { SetDummy24(value); } + } + public Builder SetDummy24(int value) { + result.hasDummy24 = true; + result.dummy24_ = value; + return this; + } + public Builder ClearDummy24() { + result.hasDummy24 = false; + result.dummy24_ = 0; + return this; + } + + public bool HasDummy25 { + get { return result.HasDummy25; } + } + public int Dummy25 { + get { return result.Dummy25; } + set { SetDummy25(value); } + } + public Builder SetDummy25(int value) { + result.hasDummy25 = true; + result.dummy25_ = value; + return this; + } + public Builder ClearDummy25() { + result.hasDummy25 = false; + result.dummy25_ = 0; + return this; + } + + public bool HasDummy26 { + get { return result.HasDummy26; } + } + public int Dummy26 { + get { return result.Dummy26; } + set { SetDummy26(value); } + } + public Builder SetDummy26(int value) { + result.hasDummy26 = true; + result.dummy26_ = value; + return this; + } + public Builder ClearDummy26() { + result.hasDummy26 = false; + result.dummy26_ = 0; + return this; + } + + public bool HasDummy27 { + get { return result.HasDummy27; } + } + public int Dummy27 { + get { return result.Dummy27; } + set { SetDummy27(value); } + } + public Builder SetDummy27(int value) { + result.hasDummy27 = true; + result.dummy27_ = value; + return this; + } + public Builder ClearDummy27() { + result.hasDummy27 = false; + result.dummy27_ = 0; + return this; + } + + public bool HasDummy28 { + get { return result.HasDummy28; } + } + public int Dummy28 { + get { return result.Dummy28; } + set { SetDummy28(value); } + } + public Builder SetDummy28(int value) { + result.hasDummy28 = true; + result.dummy28_ = value; + return this; + } + public Builder ClearDummy28() { + result.hasDummy28 = false; + result.dummy28_ = 0; + return this; + } + + public bool HasDummy29 { + get { return result.HasDummy29; } + } + public int Dummy29 { + get { return result.Dummy29; } + set { SetDummy29(value); } + } + public Builder SetDummy29(int value) { + result.hasDummy29 = true; + result.dummy29_ = value; + return this; + } + public Builder ClearDummy29() { + result.hasDummy29 = false; + result.dummy29_ = 0; + return this; + } + + public bool HasDummy30 { + get { return result.HasDummy30; } + } + public int Dummy30 { + get { return result.Dummy30; } + set { SetDummy30(value); } + } + public Builder SetDummy30(int value) { + result.hasDummy30 = true; + result.dummy30_ = value; + return this; + } + public Builder ClearDummy30() { + result.hasDummy30 = false; + result.dummy30_ = 0; + return this; + } + + public bool HasDummy31 { + get { return result.HasDummy31; } + } + public int Dummy31 { + get { return result.Dummy31; } + set { SetDummy31(value); } + } + public Builder SetDummy31(int value) { + result.hasDummy31 = true; + result.dummy31_ = value; + return this; + } + public Builder ClearDummy31() { + result.hasDummy31 = false; + result.dummy31_ = 0; + return this; + } + + public bool HasDummy32 { + get { return result.HasDummy32; } + } + public int Dummy32 { + get { return result.Dummy32; } + set { SetDummy32(value); } + } + public Builder SetDummy32(int value) { + result.hasDummy32 = true; + result.dummy32_ = value; + return this; + } + public Builder ClearDummy32() { + result.hasDummy32 = false; + result.dummy32_ = 0; + return this; + } + + public bool HasC { + get { return result.HasC; } + } + public int C { + get { return result.C; } + set { SetC(value); } + } + public Builder SetC(int value) { + result.hasC = true; + result.c_ = value; + return this; + } + public Builder ClearC() { + result.hasC = false; + result.c_ = 0; + return this; + } + } + } + + public sealed partial class TestRequiredForeign : pb::GeneratedMessage<TestRequiredForeign, TestRequiredForeign.Builder> { + private static readonly TestRequiredForeign defaultInstance = new Builder().BuildPartial(); + public static TestRequiredForeign DefaultInstance { + get { return defaultInstance; } + } + + public override TestRequiredForeign DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestRequiredForeign ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRequiredForeign__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestRequiredForeign, TestRequiredForeign.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRequiredForeign__FieldAccessorTable; } + } + + private bool hasOptionalMessage; + private global::Google.ProtocolBuffers.TestProtos.TestRequired optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestRequired.DefaultInstance; + public bool HasOptionalMessage { + get { return hasOptionalMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequired OptionalMessage { + get { return optionalMessage_; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestRequired> repeatedMessage_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.TestRequired>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestRequired> RepeatedMessageList { + get { return repeatedMessage_; } + } + public int RepeatedMessageCount { + get { return repeatedMessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequired GetRepeatedMessage(int index) { + return repeatedMessage_[index]; + } + + private bool hasDummy; + private int dummy_ = 0; + public bool HasDummy { + get { return hasDummy; } + } + public int Dummy { + get { return dummy_; } + } + + public override bool IsInitialized { + get { + if (HasOptionalMessage) { + if (!OptionalMessage.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestRequired element in RepeatedMessageList) { + if (!element.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasOptionalMessage) { + output.WriteMessage(1, OptionalMessage); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestRequired element in RepeatedMessageList) { + output.WriteMessage(2, element); + } + if (HasDummy) { + output.WriteInt32(3, Dummy); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasOptionalMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(1, OptionalMessage); + } + foreach (global::Google.ProtocolBuffers.TestProtos.TestRequired element in RepeatedMessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + if (HasDummy) { + size += pb::CodedOutputStream.ComputeInt32Size(3, Dummy); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestRequiredForeign ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRequiredForeign ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestRequiredForeign prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestRequiredForeign, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestRequiredForeign result = new TestRequiredForeign(); + + protected override TestRequiredForeign MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestRequiredForeign(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestRequiredForeign.Descriptor; } + } + + public override TestRequiredForeign DefaultInstanceForType { + get { return TestRequiredForeign.DefaultInstance; } + } + + public override TestRequiredForeign BuildPartial() { + result.repeatedMessage_.MakeReadOnly(); + TestRequiredForeign returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestRequiredForeign) { + return MergeFrom((TestRequiredForeign) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestRequiredForeign other) { + if (other == TestRequiredForeign.DefaultInstance) return this; + if (other.HasOptionalMessage) { + MergeOptionalMessage(other.OptionalMessage); + } + if (other.repeatedMessage_.Count != 0) { + base.AddRange(other.repeatedMessage_, result.repeatedMessage_); + } + if (other.HasDummy) { + Dummy = other.Dummy; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestRequired.CreateBuilder(); + if (HasOptionalMessage) { + subBuilder.MergeFrom(OptionalMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalMessage = subBuilder.BuildPartial(); + break; + } + case 18: { + global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestRequired.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedMessage(subBuilder.BuildPartial()); + break; + } + case 24: { + Dummy = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasOptionalMessage { + get { return result.HasOptionalMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequired OptionalMessage { + get { return result.OptionalMessage; } + set { SetOptionalMessage(value); } + } + public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired value) { + result.hasOptionalMessage = true; + result.optionalMessage_ = value; + return this; + } + public Builder SetOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder builderForValue) { + result.hasOptionalMessage = true; + result.optionalMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired value) { + if (result.HasOptionalMessage && + result.optionalMessage_ != global::Google.ProtocolBuffers.TestProtos.TestRequired.DefaultInstance) { + result.optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestRequired.CreateBuilder(result.optionalMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalMessage_ = value; + } + result.hasOptionalMessage = true; + return this; + } + public Builder ClearOptionalMessage() { + result.hasOptionalMessage = false; + result.optionalMessage_ = global::Google.ProtocolBuffers.TestProtos.TestRequired.DefaultInstance; + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.TestRequired> RepeatedMessageList { + get { return result.repeatedMessage_; } + } + public int RepeatedMessageCount { + get { return result.RepeatedMessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRequired GetRepeatedMessage(int index) { + return result.GetRepeatedMessage(index); + } + public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestRequired value) { + result.repeatedMessage_[index] = value; + return this; + } + public Builder SetRepeatedMessage(int index, global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder builderForValue) { + result.repeatedMessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired value) { + result.repeatedMessage_.Add(value); + return this; + } + public Builder AddRepeatedMessage(global::Google.ProtocolBuffers.TestProtos.TestRequired.Builder builderForValue) { + result.repeatedMessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedMessage(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.TestRequired> values) { + base.AddRange(values, result.repeatedMessage_); + return this; + } + public Builder ClearRepeatedMessage() { + result.repeatedMessage_.Clear(); + return this; + } + + public bool HasDummy { + get { return result.HasDummy; } + } + public int Dummy { + get { return result.Dummy; } + set { SetDummy(value); } + } + public Builder SetDummy(int value) { + result.hasDummy = true; + result.dummy_ = value; + return this; + } + public Builder ClearDummy() { + result.hasDummy = false; + result.dummy_ = 0; + return this; + } + } + } + + public sealed partial class TestForeignNested : pb::GeneratedMessage<TestForeignNested, TestForeignNested.Builder> { + private static readonly TestForeignNested defaultInstance = new Builder().BuildPartial(); + public static TestForeignNested DefaultInstance { + get { return defaultInstance; } + } + + public override TestForeignNested DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestForeignNested ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestForeignNested__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestForeignNested, TestForeignNested.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestForeignNested__FieldAccessorTable; } + } + + private bool hasForeignNested; + private global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage foreignNested_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance; + public bool HasForeignNested { + get { return hasForeignNested; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage ForeignNested { + get { return foreignNested_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasForeignNested) { + output.WriteMessage(1, ForeignNested); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasForeignNested) { + size += pb::CodedOutputStream.ComputeMessageSize(1, ForeignNested); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestForeignNested ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestForeignNested ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestForeignNested ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestForeignNested ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestForeignNested ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestForeignNested ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestForeignNested ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestForeignNested ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestForeignNested prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestForeignNested, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestForeignNested result = new TestForeignNested(); + + protected override TestForeignNested MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestForeignNested(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestForeignNested.Descriptor; } + } + + public override TestForeignNested DefaultInstanceForType { + get { return TestForeignNested.DefaultInstance; } + } + + public override TestForeignNested BuildPartial() { + TestForeignNested returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestForeignNested) { + return MergeFrom((TestForeignNested) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestForeignNested other) { + if (other == TestForeignNested.DefaultInstance) return this; + if (other.HasForeignNested) { + MergeForeignNested(other.ForeignNested); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(); + if (HasForeignNested) { + subBuilder.MergeFrom(ForeignNested); + } + input.ReadMessage(subBuilder, extensionRegistry); + ForeignNested = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasForeignNested { + get { return result.HasForeignNested; } + } + public global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage ForeignNested { + get { return result.ForeignNested; } + set { SetForeignNested(value); } + } + public Builder SetForeignNested(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + result.hasForeignNested = true; + result.foreignNested_ = value; + return this; + } + public Builder SetForeignNested(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.Builder builderForValue) { + result.hasForeignNested = true; + result.foreignNested_ = builderForValue.Build(); + return this; + } + public Builder MergeForeignNested(global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage value) { + if (result.HasForeignNested && + result.foreignNested_ != global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance) { + result.foreignNested_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.CreateBuilder(result.foreignNested_).MergeFrom(value).BuildPartial(); + } else { + result.foreignNested_ = value; + } + result.hasForeignNested = true; + return this; + } + public Builder ClearForeignNested() { + result.hasForeignNested = false; + result.foreignNested_ = global::Google.ProtocolBuffers.TestProtos.TestAllTypes.Types.NestedMessage.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestEmptyMessage : pb::GeneratedMessage<TestEmptyMessage, TestEmptyMessage.Builder> { + private static readonly TestEmptyMessage defaultInstance = new Builder().BuildPartial(); + public static TestEmptyMessage DefaultInstance { + get { return defaultInstance; } + } + + public override TestEmptyMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestEmptyMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestEmptyMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestEmptyMessage, TestEmptyMessage.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestEmptyMessage__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestEmptyMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmptyMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestEmptyMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestEmptyMessage, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestEmptyMessage result = new TestEmptyMessage(); + + protected override TestEmptyMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestEmptyMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestEmptyMessage.Descriptor; } + } + + public override TestEmptyMessage DefaultInstanceForType { + get { return TestEmptyMessage.DefaultInstance; } + } + + public override TestEmptyMessage BuildPartial() { + TestEmptyMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestEmptyMessage) { + return MergeFrom((TestEmptyMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestEmptyMessage other) { + if (other == TestEmptyMessage.DefaultInstance) return this; + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class TestEmptyMessageWithExtensions : pb::ExtendableMessage<TestEmptyMessageWithExtensions, TestEmptyMessageWithExtensions.Builder> { + private static readonly TestEmptyMessageWithExtensions defaultInstance = new Builder().BuildPartial(); + public static TestEmptyMessageWithExtensions DefaultInstance { + get { return defaultInstance; } + } + + public override TestEmptyMessageWithExtensions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestEmptyMessageWithExtensions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestEmptyMessageWithExtensions, TestEmptyMessageWithExtensions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestEmptyMessageWithExtensions__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<TestEmptyMessageWithExtensions, TestEmptyMessageWithExtensions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestEmptyMessageWithExtensions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestEmptyMessageWithExtensions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestEmptyMessageWithExtensions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<TestEmptyMessageWithExtensions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestEmptyMessageWithExtensions result = new TestEmptyMessageWithExtensions(); + + protected override TestEmptyMessageWithExtensions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestEmptyMessageWithExtensions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestEmptyMessageWithExtensions.Descriptor; } + } + + public override TestEmptyMessageWithExtensions DefaultInstanceForType { + get { return TestEmptyMessageWithExtensions.DefaultInstance; } + } + + public override TestEmptyMessageWithExtensions BuildPartial() { + TestEmptyMessageWithExtensions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestEmptyMessageWithExtensions) { + return MergeFrom((TestEmptyMessageWithExtensions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestEmptyMessageWithExtensions other) { + if (other == TestEmptyMessageWithExtensions.DefaultInstance) return this; + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class TestReallyLargeTagNumber : pb::GeneratedMessage<TestReallyLargeTagNumber, TestReallyLargeTagNumber.Builder> { + private static readonly TestReallyLargeTagNumber defaultInstance = new Builder().BuildPartial(); + public static TestReallyLargeTagNumber DefaultInstance { + get { return defaultInstance; } + } + + public override TestReallyLargeTagNumber DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestReallyLargeTagNumber ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestReallyLargeTagNumber__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestReallyLargeTagNumber, TestReallyLargeTagNumber.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestReallyLargeTagNumber__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + private bool hasBb; + private int bb_ = 0; + public bool HasBb { + get { return hasBb; } + } + public int Bb { + get { return bb_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + if (HasBb) { + output.WriteInt32(268435455, Bb); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + if (HasBb) { + size += pb::CodedOutputStream.ComputeInt32Size(268435455, Bb); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestReallyLargeTagNumber ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestReallyLargeTagNumber ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestReallyLargeTagNumber prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestReallyLargeTagNumber, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestReallyLargeTagNumber result = new TestReallyLargeTagNumber(); + + protected override TestReallyLargeTagNumber MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestReallyLargeTagNumber(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestReallyLargeTagNumber.Descriptor; } + } + + public override TestReallyLargeTagNumber DefaultInstanceForType { + get { return TestReallyLargeTagNumber.DefaultInstance; } + } + + public override TestReallyLargeTagNumber BuildPartial() { + TestReallyLargeTagNumber returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestReallyLargeTagNumber) { + return MergeFrom((TestReallyLargeTagNumber) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestReallyLargeTagNumber other) { + if (other == TestReallyLargeTagNumber.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + if (other.HasBb) { + Bb = other.Bb; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + case 2147483640: { + Bb = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + + public bool HasBb { + get { return result.HasBb; } + } + public int Bb { + get { return result.Bb; } + set { SetBb(value); } + } + public Builder SetBb(int value) { + result.hasBb = true; + result.bb_ = value; + return this; + } + public Builder ClearBb() { + result.hasBb = false; + result.bb_ = 0; + return this; + } + } + } + + public sealed partial class TestRecursiveMessage : pb::GeneratedMessage<TestRecursiveMessage, TestRecursiveMessage.Builder> { + private static readonly TestRecursiveMessage defaultInstance = new Builder().BuildPartial(); + public static TestRecursiveMessage DefaultInstance { + get { return defaultInstance; } + } + + public override TestRecursiveMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestRecursiveMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRecursiveMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestRecursiveMessage, TestRecursiveMessage.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestRecursiveMessage__FieldAccessorTable; } + } + + private bool hasA; + private global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage a_ = global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.DefaultInstance; + public bool HasA { + get { return hasA; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage A { + get { return a_; } + } + + private bool hasI; + private int i_ = 0; + public bool HasI { + get { return hasI; } + } + public int I { + get { return i_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteMessage(1, A); + } + if (HasI) { + output.WriteInt32(2, I); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeMessageSize(1, A); + } + if (HasI) { + size += pb::CodedOutputStream.ComputeInt32Size(2, I); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestRecursiveMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestRecursiveMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestRecursiveMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestRecursiveMessage, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestRecursiveMessage result = new TestRecursiveMessage(); + + protected override TestRecursiveMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestRecursiveMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestRecursiveMessage.Descriptor; } + } + + public override TestRecursiveMessage DefaultInstanceForType { + get { return TestRecursiveMessage.DefaultInstance; } + } + + public override TestRecursiveMessage BuildPartial() { + TestRecursiveMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestRecursiveMessage) { + return MergeFrom((TestRecursiveMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestRecursiveMessage other) { + if (other == TestRecursiveMessage.DefaultInstance) return this; + if (other.HasA) { + MergeA(other.A); + } + if (other.HasI) { + I = other.I; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.CreateBuilder(); + if (HasA) { + subBuilder.MergeFrom(A); + } + input.ReadMessage(subBuilder, extensionRegistry); + A = subBuilder.BuildPartial(); + break; + } + case 16: { + I = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder SetA(global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.Builder builderForValue) { + result.hasA = true; + result.a_ = builderForValue.Build(); + return this; + } + public Builder MergeA(global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage value) { + if (result.HasA && + result.a_ != global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.DefaultInstance) { + result.a_ = global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.CreateBuilder(result.a_).MergeFrom(value).BuildPartial(); + } else { + result.a_ = value; + } + result.hasA = true; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = global::Google.ProtocolBuffers.TestProtos.TestRecursiveMessage.DefaultInstance; + return this; + } + + public bool HasI { + get { return result.HasI; } + } + public int I { + get { return result.I; } + set { SetI(value); } + } + public Builder SetI(int value) { + result.hasI = true; + result.i_ = value; + return this; + } + public Builder ClearI() { + result.hasI = false; + result.i_ = 0; + return this; + } + } + } + + public sealed partial class TestMutualRecursionA : pb::GeneratedMessage<TestMutualRecursionA, TestMutualRecursionA.Builder> { + private static readonly TestMutualRecursionA defaultInstance = new Builder().BuildPartial(); + public static TestMutualRecursionA DefaultInstance { + get { return defaultInstance; } + } + + public override TestMutualRecursionA DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMutualRecursionA ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestMutualRecursionA__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestMutualRecursionA, TestMutualRecursionA.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestMutualRecursionA__FieldAccessorTable; } + } + + private bool hasBb; + private global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB bb_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.DefaultInstance; + public bool HasBb { + get { return hasBb; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB Bb { + get { return bb_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasBb) { + output.WriteMessage(1, Bb); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasBb) { + size += pb::CodedOutputStream.ComputeMessageSize(1, Bb); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMutualRecursionA ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMutualRecursionA ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMutualRecursionA prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestMutualRecursionA, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMutualRecursionA result = new TestMutualRecursionA(); + + protected override TestMutualRecursionA MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMutualRecursionA(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMutualRecursionA.Descriptor; } + } + + public override TestMutualRecursionA DefaultInstanceForType { + get { return TestMutualRecursionA.DefaultInstance; } + } + + public override TestMutualRecursionA BuildPartial() { + TestMutualRecursionA returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMutualRecursionA) { + return MergeFrom((TestMutualRecursionA) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMutualRecursionA other) { + if (other == TestMutualRecursionA.DefaultInstance) return this; + if (other.HasBb) { + MergeBb(other.Bb); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.CreateBuilder(); + if (HasBb) { + subBuilder.MergeFrom(Bb); + } + input.ReadMessage(subBuilder, extensionRegistry); + Bb = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasBb { + get { return result.HasBb; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB Bb { + get { return result.Bb; } + set { SetBb(value); } + } + public Builder SetBb(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB value) { + result.hasBb = true; + result.bb_ = value; + return this; + } + public Builder SetBb(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.Builder builderForValue) { + result.hasBb = true; + result.bb_ = builderForValue.Build(); + return this; + } + public Builder MergeBb(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB value) { + if (result.HasBb && + result.bb_ != global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.DefaultInstance) { + result.bb_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.CreateBuilder(result.bb_).MergeFrom(value).BuildPartial(); + } else { + result.bb_ = value; + } + result.hasBb = true; + return this; + } + public Builder ClearBb() { + result.hasBb = false; + result.bb_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionB.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestMutualRecursionB : pb::GeneratedMessage<TestMutualRecursionB, TestMutualRecursionB.Builder> { + private static readonly TestMutualRecursionB defaultInstance = new Builder().BuildPartial(); + public static TestMutualRecursionB DefaultInstance { + get { return defaultInstance; } + } + + public override TestMutualRecursionB DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestMutualRecursionB ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestMutualRecursionB__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestMutualRecursionB, TestMutualRecursionB.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestMutualRecursionB__FieldAccessorTable; } + } + + private bool hasA; + private global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA a_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.DefaultInstance; + public bool HasA { + get { return hasA; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA A { + get { return a_; } + } + + private bool hasOptionalInt32; + private int optionalInt32_ = 0; + public bool HasOptionalInt32 { + get { return hasOptionalInt32; } + } + public int OptionalInt32 { + get { return optionalInt32_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteMessage(1, A); + } + if (HasOptionalInt32) { + output.WriteInt32(2, OptionalInt32); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeMessageSize(1, A); + } + if (HasOptionalInt32) { + size += pb::CodedOutputStream.ComputeInt32Size(2, OptionalInt32); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestMutualRecursionB ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestMutualRecursionB ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestMutualRecursionB prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestMutualRecursionB, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestMutualRecursionB result = new TestMutualRecursionB(); + + protected override TestMutualRecursionB MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestMutualRecursionB(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestMutualRecursionB.Descriptor; } + } + + public override TestMutualRecursionB DefaultInstanceForType { + get { return TestMutualRecursionB.DefaultInstance; } + } + + public override TestMutualRecursionB BuildPartial() { + TestMutualRecursionB returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestMutualRecursionB) { + return MergeFrom((TestMutualRecursionB) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestMutualRecursionB other) { + if (other == TestMutualRecursionB.DefaultInstance) return this; + if (other.HasA) { + MergeA(other.A); + } + if (other.HasOptionalInt32) { + OptionalInt32 = other.OptionalInt32; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.CreateBuilder(); + if (HasA) { + subBuilder.MergeFrom(A); + } + input.ReadMessage(subBuilder, extensionRegistry); + A = subBuilder.BuildPartial(); + break; + } + case 16: { + OptionalInt32 = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder SetA(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.Builder builderForValue) { + result.hasA = true; + result.a_ = builderForValue.Build(); + return this; + } + public Builder MergeA(global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA value) { + if (result.HasA && + result.a_ != global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.DefaultInstance) { + result.a_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.CreateBuilder(result.a_).MergeFrom(value).BuildPartial(); + } else { + result.a_ = value; + } + result.hasA = true; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = global::Google.ProtocolBuffers.TestProtos.TestMutualRecursionA.DefaultInstance; + return this; + } + + public bool HasOptionalInt32 { + get { return result.HasOptionalInt32; } + } + public int OptionalInt32 { + get { return result.OptionalInt32; } + set { SetOptionalInt32(value); } + } + public Builder SetOptionalInt32(int value) { + result.hasOptionalInt32 = true; + result.optionalInt32_ = value; + return this; + } + public Builder ClearOptionalInt32() { + result.hasOptionalInt32 = false; + result.optionalInt32_ = 0; + return this; + } + } + } + + public sealed partial class TestDupFieldNumber : pb::GeneratedMessage<TestDupFieldNumber, TestDupFieldNumber.Builder> { + private static readonly TestDupFieldNumber defaultInstance = new Builder().BuildPartial(); + public static TestDupFieldNumber DefaultInstance { + get { return defaultInstance; } + } + + public override TestDupFieldNumber DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestDupFieldNumber ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestDupFieldNumber, TestDupFieldNumber.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class Foo : pb::GeneratedMessage<Foo, Foo.Builder> { + private static readonly Foo defaultInstance = new Builder().BuildPartial(); + public static Foo DefaultInstance { + get { return defaultInstance; } + } + + public override Foo DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Foo ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber_Foo__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<Foo, Foo.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber_Foo__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Foo ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Foo ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Foo ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Foo ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Foo ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Foo ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Foo ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Foo ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Foo prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<Foo, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Foo result = new Foo(); + + protected override Foo MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Foo(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Foo.Descriptor; } + } + + public override Foo DefaultInstanceForType { + get { return Foo.DefaultInstance; } + } + + public override Foo BuildPartial() { + Foo returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Foo) { + return MergeFrom((Foo) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Foo other) { + if (other == Foo.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + public sealed partial class Bar : pb::GeneratedMessage<Bar, Bar.Builder> { + private static readonly Bar defaultInstance = new Builder().BuildPartial(); + public static Bar DefaultInstance { + get { return defaultInstance; } + } + + public override Bar DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override Bar ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber_Bar__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<Bar, Bar.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestDupFieldNumber_Bar__FieldAccessorTable; } + } + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static Bar ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Bar ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Bar ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static Bar ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static Bar ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Bar ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Bar ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static Bar ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(Bar prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<Bar, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + Bar result = new Bar(); + + protected override Bar MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new Bar(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return Bar.Descriptor; } + } + + public override Bar DefaultInstanceForType { + get { return Bar.DefaultInstance; } + } + + public override Bar BuildPartial() { + Bar returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is Bar) { + return MergeFrom((Bar) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(Bar other) { + if (other == Bar.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + } + } + + } + #endregion + + private bool hasA; + private int a_ = 0; + public bool HasA { + get { return hasA; } + } + public int A { + get { return a_; } + } + + private bool hasFoo; + private global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo foo_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.DefaultInstance; + public bool HasFoo { + get { return hasFoo; } + } + public global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo Foo { + get { return foo_; } + } + + private bool hasBar; + private global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar bar_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.DefaultInstance; + public bool HasBar { + get { return hasBar; } + } + public global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar Bar { + get { return bar_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasA) { + output.WriteInt32(1, A); + } + if (HasFoo) { + output.WriteGroup(2, Foo); + } + if (HasBar) { + output.WriteGroup(3, Bar); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasA) { + size += pb::CodedOutputStream.ComputeInt32Size(1, A); + } + if (HasFoo) { + size += pb::CodedOutputStream.ComputeGroupSize(2, Foo); + } + if (HasBar) { + size += pb::CodedOutputStream.ComputeGroupSize(3, Bar); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestDupFieldNumber ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestDupFieldNumber ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestDupFieldNumber prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestDupFieldNumber, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestDupFieldNumber result = new TestDupFieldNumber(); + + protected override TestDupFieldNumber MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestDupFieldNumber(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestDupFieldNumber.Descriptor; } + } + + public override TestDupFieldNumber DefaultInstanceForType { + get { return TestDupFieldNumber.DefaultInstance; } + } + + public override TestDupFieldNumber BuildPartial() { + TestDupFieldNumber returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestDupFieldNumber) { + return MergeFrom((TestDupFieldNumber) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestDupFieldNumber other) { + if (other == TestDupFieldNumber.DefaultInstance) return this; + if (other.HasA) { + A = other.A; + } + if (other.HasFoo) { + MergeFoo(other.Foo); + } + if (other.HasBar) { + MergeBar(other.Bar); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + A = input.ReadInt32(); + break; + } + case 19: { + global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.CreateBuilder(); + if (HasFoo) { + subBuilder.MergeFrom(Foo); + } + input.ReadGroup(2, subBuilder, extensionRegistry); + Foo = subBuilder.BuildPartial(); + break; + } + case 27: { + global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.CreateBuilder(); + if (HasBar) { + subBuilder.MergeFrom(Bar); + } + input.ReadGroup(3, subBuilder, extensionRegistry); + Bar = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasA { + get { return result.HasA; } + } + public int A { + get { return result.A; } + set { SetA(value); } + } + public Builder SetA(int value) { + result.hasA = true; + result.a_ = value; + return this; + } + public Builder ClearA() { + result.hasA = false; + result.a_ = 0; + return this; + } + + public bool HasFoo { + get { return result.HasFoo; } + } + public global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo Foo { + get { return result.Foo; } + set { SetFoo(value); } + } + public Builder SetFoo(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo value) { + result.hasFoo = true; + result.foo_ = value; + return this; + } + public Builder SetFoo(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.Builder builderForValue) { + result.hasFoo = true; + result.foo_ = builderForValue.Build(); + return this; + } + public Builder MergeFoo(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo value) { + if (result.HasFoo && + result.foo_ != global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.DefaultInstance) { + result.foo_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.CreateBuilder(result.foo_).MergeFrom(value).BuildPartial(); + } else { + result.foo_ = value; + } + result.hasFoo = true; + return this; + } + public Builder ClearFoo() { + result.hasFoo = false; + result.foo_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Foo.DefaultInstance; + return this; + } + + public bool HasBar { + get { return result.HasBar; } + } + public global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar Bar { + get { return result.Bar; } + set { SetBar(value); } + } + public Builder SetBar(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar value) { + result.hasBar = true; + result.bar_ = value; + return this; + } + public Builder SetBar(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.Builder builderForValue) { + result.hasBar = true; + result.bar_ = builderForValue.Build(); + return this; + } + public Builder MergeBar(global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar value) { + if (result.HasBar && + result.bar_ != global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.DefaultInstance) { + result.bar_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.CreateBuilder(result.bar_).MergeFrom(value).BuildPartial(); + } else { + result.bar_ = value; + } + result.hasBar = true; + return this; + } + public Builder ClearBar() { + result.hasBar = false; + result.bar_ = global::Google.ProtocolBuffers.TestProtos.TestDupFieldNumber.Types.Bar.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestNestedMessageHasBits : pb::GeneratedMessage<TestNestedMessageHasBits, TestNestedMessageHasBits.Builder> { + private static readonly TestNestedMessageHasBits defaultInstance = new Builder().BuildPartial(); + public static TestNestedMessageHasBits DefaultInstance { + get { return defaultInstance; } + } + + public override TestNestedMessageHasBits DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestNestedMessageHasBits ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestNestedMessageHasBits__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestNestedMessageHasBits, TestNestedMessageHasBits.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestNestedMessageHasBits__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class NestedMessage : pb::GeneratedMessage<NestedMessage, NestedMessage.Builder> { + private static readonly NestedMessage defaultInstance = new Builder().BuildPartial(); + public static NestedMessage DefaultInstance { + get { return defaultInstance; } + } + + public override NestedMessage DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NestedMessage ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<NestedMessage, NestedMessage.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestNestedMessageHasBits_NestedMessage__FieldAccessorTable; } + } + + private pbc::PopsicleList<int> nestedmessageRepeatedInt32_ = new pbc::PopsicleList<int>(); + public scg::IList<int> NestedmessageRepeatedInt32List { + get { return pbc::Lists.AsReadOnly(nestedmessageRepeatedInt32_); } + } + public int NestedmessageRepeatedInt32Count { + get { return nestedmessageRepeatedInt32_.Count; } + } + public int GetNestedmessageRepeatedInt32(int index) { + return nestedmessageRepeatedInt32_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> nestedmessageRepeatedForeignmessage_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> NestedmessageRepeatedForeignmessageList { + get { return nestedmessageRepeatedForeignmessage_; } + } + public int NestedmessageRepeatedForeignmessageCount { + get { return nestedmessageRepeatedForeignmessage_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetNestedmessageRepeatedForeignmessage(int index) { + return nestedmessageRepeatedForeignmessage_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (int element in NestedmessageRepeatedInt32List) { + output.WriteInt32(1, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in NestedmessageRepeatedForeignmessageList) { + output.WriteMessage(2, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (int element in NestedmessageRepeatedInt32List) { + size += pb::CodedOutputStream.ComputeInt32Size(1, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in NestedmessageRepeatedForeignmessageList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NestedMessage ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NestedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NestedMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NestedMessage ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(NestedMessage prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<NestedMessage, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NestedMessage result = new NestedMessage(); + + protected override NestedMessage MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NestedMessage(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return NestedMessage.Descriptor; } + } + + public override NestedMessage DefaultInstanceForType { + get { return NestedMessage.DefaultInstance; } + } + + public override NestedMessage BuildPartial() { + result.nestedmessageRepeatedInt32_.MakeReadOnly(); + result.nestedmessageRepeatedForeignmessage_.MakeReadOnly(); + NestedMessage returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NestedMessage) { + return MergeFrom((NestedMessage) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NestedMessage other) { + if (other == NestedMessage.DefaultInstance) return this; + if (other.nestedmessageRepeatedInt32_.Count != 0) { + base.AddRange(other.nestedmessageRepeatedInt32_, result.nestedmessageRepeatedInt32_); + } + if (other.nestedmessageRepeatedForeignmessage_.Count != 0) { + base.AddRange(other.nestedmessageRepeatedForeignmessage_, result.nestedmessageRepeatedForeignmessage_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + AddNestedmessageRepeatedInt32(input.ReadInt32()); + break; + } + case 18: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddNestedmessageRepeatedForeignmessage(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public scg::IList<int> NestedmessageRepeatedInt32List { + get { return result.nestedmessageRepeatedInt32_; } + } + public int NestedmessageRepeatedInt32Count { + get { return result.NestedmessageRepeatedInt32Count; } + } + public int GetNestedmessageRepeatedInt32(int index) { + return result.GetNestedmessageRepeatedInt32(index); + } + public Builder SetNestedmessageRepeatedInt32(int index, int value) { + result.nestedmessageRepeatedInt32_[index] = value; + return this; + } + public Builder AddNestedmessageRepeatedInt32(int value) { + result.nestedmessageRepeatedInt32_.Add(value); + return this; + } + public Builder AddRangeNestedmessageRepeatedInt32(scg::IEnumerable<int> values) { + base.AddRange(values, result.nestedmessageRepeatedInt32_); + return this; + } + public Builder ClearNestedmessageRepeatedInt32() { + result.nestedmessageRepeatedInt32_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> NestedmessageRepeatedForeignmessageList { + get { return result.nestedmessageRepeatedForeignmessage_; } + } + public int NestedmessageRepeatedForeignmessageCount { + get { return result.NestedmessageRepeatedForeignmessageCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetNestedmessageRepeatedForeignmessage(int index) { + return result.GetNestedmessageRepeatedForeignmessage(index); + } + public Builder SetNestedmessageRepeatedForeignmessage(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.nestedmessageRepeatedForeignmessage_[index] = value; + return this; + } + public Builder SetNestedmessageRepeatedForeignmessage(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.nestedmessageRepeatedForeignmessage_[index] = builderForValue.Build(); + return this; + } + public Builder AddNestedmessageRepeatedForeignmessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.nestedmessageRepeatedForeignmessage_.Add(value); + return this; + } + public Builder AddNestedmessageRepeatedForeignmessage(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.nestedmessageRepeatedForeignmessage_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeNestedmessageRepeatedForeignmessage(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> values) { + base.AddRange(values, result.nestedmessageRepeatedForeignmessage_); + return this; + } + public Builder ClearNestedmessageRepeatedForeignmessage() { + result.nestedmessageRepeatedForeignmessage_.Clear(); + return this; + } + } + } + + } + #endregion + + private bool hasOptionalNestedMessage; + private global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.DefaultInstance; + public bool HasOptionalNestedMessage { + get { return hasOptionalNestedMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage OptionalNestedMessage { + get { return optionalNestedMessage_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasOptionalNestedMessage) { + output.WriteMessage(1, OptionalNestedMessage); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasOptionalNestedMessage) { + size += pb::CodedOutputStream.ComputeMessageSize(1, OptionalNestedMessage); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestNestedMessageHasBits ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestNestedMessageHasBits ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestNestedMessageHasBits prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestNestedMessageHasBits, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestNestedMessageHasBits result = new TestNestedMessageHasBits(); + + protected override TestNestedMessageHasBits MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestNestedMessageHasBits(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestNestedMessageHasBits.Descriptor; } + } + + public override TestNestedMessageHasBits DefaultInstanceForType { + get { return TestNestedMessageHasBits.DefaultInstance; } + } + + public override TestNestedMessageHasBits BuildPartial() { + TestNestedMessageHasBits returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestNestedMessageHasBits) { + return MergeFrom((TestNestedMessageHasBits) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestNestedMessageHasBits other) { + if (other == TestNestedMessageHasBits.DefaultInstance) return this; + if (other.HasOptionalNestedMessage) { + MergeOptionalNestedMessage(other.OptionalNestedMessage); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.CreateBuilder(); + if (HasOptionalNestedMessage) { + subBuilder.MergeFrom(OptionalNestedMessage); + } + input.ReadMessage(subBuilder, extensionRegistry); + OptionalNestedMessage = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasOptionalNestedMessage { + get { return result.HasOptionalNestedMessage; } + } + public global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage OptionalNestedMessage { + get { return result.OptionalNestedMessage; } + set { SetOptionalNestedMessage(value); } + } + public Builder SetOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage value) { + result.hasOptionalNestedMessage = true; + result.optionalNestedMessage_ = value; + return this; + } + public Builder SetOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.Builder builderForValue) { + result.hasOptionalNestedMessage = true; + result.optionalNestedMessage_ = builderForValue.Build(); + return this; + } + public Builder MergeOptionalNestedMessage(global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage value) { + if (result.HasOptionalNestedMessage && + result.optionalNestedMessage_ != global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.DefaultInstance) { + result.optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.CreateBuilder(result.optionalNestedMessage_).MergeFrom(value).BuildPartial(); + } else { + result.optionalNestedMessage_ = value; + } + result.hasOptionalNestedMessage = true; + return this; + } + public Builder ClearOptionalNestedMessage() { + result.hasOptionalNestedMessage = false; + result.optionalNestedMessage_ = global::Google.ProtocolBuffers.TestProtos.TestNestedMessageHasBits.Types.NestedMessage.DefaultInstance; + return this; + } + } + } + + public sealed partial class TestCamelCaseFieldNames : pb::GeneratedMessage<TestCamelCaseFieldNames, TestCamelCaseFieldNames.Builder> { + private static readonly TestCamelCaseFieldNames defaultInstance = new Builder().BuildPartial(); + public static TestCamelCaseFieldNames DefaultInstance { + get { return defaultInstance; } + } + + public override TestCamelCaseFieldNames DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestCamelCaseFieldNames ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestCamelCaseFieldNames__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestCamelCaseFieldNames, TestCamelCaseFieldNames.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestCamelCaseFieldNames__FieldAccessorTable; } + } + + private bool hasPrimitiveField; + private int primitiveField_ = 0; + public bool HasPrimitiveField { + get { return hasPrimitiveField; } + } + public int PrimitiveField { + get { return primitiveField_; } + } + + private bool hasStringField; + private string stringField_ = ""; + public bool HasStringField { + get { return hasStringField; } + } + public string StringField { + get { return stringField_; } + } + + private bool hasEnumField; + private global::Google.ProtocolBuffers.TestProtos.ForeignEnum enumField_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_FOO; + public bool HasEnumField { + get { return hasEnumField; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum EnumField { + get { return enumField_; } + } + + private bool hasMessageField; + private global::Google.ProtocolBuffers.TestProtos.ForeignMessage messageField_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + public bool HasMessageField { + get { return hasMessageField; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage MessageField { + get { return messageField_; } + } + + private bool hasStringPieceField; + private string stringPieceField_ = ""; + public bool HasStringPieceField { + get { return hasStringPieceField; } + } + public string StringPieceField { + get { return stringPieceField_; } + } + + private bool hasCordField; + private string cordField_ = ""; + public bool HasCordField { + get { return hasCordField; } + } + public string CordField { + get { return cordField_; } + } + + private pbc::PopsicleList<int> repeatedPrimitiveField_ = new pbc::PopsicleList<int>(); + public scg::IList<int> RepeatedPrimitiveFieldList { + get { return pbc::Lists.AsReadOnly(repeatedPrimitiveField_); } + } + public int RepeatedPrimitiveFieldCount { + get { return repeatedPrimitiveField_.Count; } + } + public int GetRepeatedPrimitiveField(int index) { + return repeatedPrimitiveField_[index]; + } + + private pbc::PopsicleList<string> repeatedStringField_ = new pbc::PopsicleList<string>(); + public scg::IList<string> RepeatedStringFieldList { + get { return pbc::Lists.AsReadOnly(repeatedStringField_); } + } + public int RepeatedStringFieldCount { + get { return repeatedStringField_.Count; } + } + public string GetRepeatedStringField(int index) { + return repeatedStringField_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> repeatedEnumField_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignEnum>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> RepeatedEnumFieldList { + get { return pbc::Lists.AsReadOnly(repeatedEnumField_); } + } + public int RepeatedEnumFieldCount { + get { return repeatedEnumField_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetRepeatedEnumField(int index) { + return repeatedEnumField_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> repeatedMessageField_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage>(); + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> RepeatedMessageFieldList { + get { return repeatedMessageField_; } + } + public int RepeatedMessageFieldCount { + get { return repeatedMessageField_.Count; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetRepeatedMessageField(int index) { + return repeatedMessageField_[index]; + } + + private pbc::PopsicleList<string> repeatedStringPieceField_ = new pbc::PopsicleList<string>(); + public scg::IList<string> RepeatedStringPieceFieldList { + get { return pbc::Lists.AsReadOnly(repeatedStringPieceField_); } + } + public int RepeatedStringPieceFieldCount { + get { return repeatedStringPieceField_.Count; } + } + public string GetRepeatedStringPieceField(int index) { + return repeatedStringPieceField_[index]; + } + + private pbc::PopsicleList<string> repeatedCordField_ = new pbc::PopsicleList<string>(); + public scg::IList<string> RepeatedCordFieldList { + get { return pbc::Lists.AsReadOnly(repeatedCordField_); } + } + public int RepeatedCordFieldCount { + get { return repeatedCordField_.Count; } + } + public string GetRepeatedCordField(int index) { + return repeatedCordField_[index]; + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasPrimitiveField) { + output.WriteInt32(1, PrimitiveField); + } + if (HasStringField) { + output.WriteString(2, StringField); + } + if (HasEnumField) { + output.WriteEnum(3, (int) EnumField); + } + if (HasMessageField) { + output.WriteMessage(4, MessageField); + } + if (HasStringPieceField) { + output.WriteString(5, StringPieceField); + } + if (HasCordField) { + output.WriteString(6, CordField); + } + foreach (int element in RepeatedPrimitiveFieldList) { + output.WriteInt32(7, element); + } + foreach (string element in RepeatedStringFieldList) { + output.WriteString(8, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedEnumFieldList) { + output.WriteEnum(9, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedMessageFieldList) { + output.WriteMessage(10, element); + } + foreach (string element in RepeatedStringPieceFieldList) { + output.WriteString(11, element); + } + foreach (string element in RepeatedCordFieldList) { + output.WriteString(12, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasPrimitiveField) { + size += pb::CodedOutputStream.ComputeInt32Size(1, PrimitiveField); + } + if (HasStringField) { + size += pb::CodedOutputStream.ComputeStringSize(2, StringField); + } + if (HasEnumField) { + size += pb::CodedOutputStream.ComputeEnumSize(3, (int) EnumField); + } + if (HasMessageField) { + size += pb::CodedOutputStream.ComputeMessageSize(4, MessageField); + } + if (HasStringPieceField) { + size += pb::CodedOutputStream.ComputeStringSize(5, StringPieceField); + } + if (HasCordField) { + size += pb::CodedOutputStream.ComputeStringSize(6, CordField); + } + foreach (int element in RepeatedPrimitiveFieldList) { + size += pb::CodedOutputStream.ComputeInt32Size(7, element); + } + foreach (string element in RepeatedStringFieldList) { + size += pb::CodedOutputStream.ComputeStringSize(8, element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignEnum element in RepeatedEnumFieldList) { + size += pb::CodedOutputStream.ComputeEnumSize(9, (int) element); + } + foreach (global::Google.ProtocolBuffers.TestProtos.ForeignMessage element in RepeatedMessageFieldList) { + size += pb::CodedOutputStream.ComputeMessageSize(10, element); + } + foreach (string element in RepeatedStringPieceFieldList) { + size += pb::CodedOutputStream.ComputeStringSize(11, element); + } + foreach (string element in RepeatedCordFieldList) { + size += pb::CodedOutputStream.ComputeStringSize(12, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestCamelCaseFieldNames ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestCamelCaseFieldNames ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestCamelCaseFieldNames prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestCamelCaseFieldNames, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestCamelCaseFieldNames result = new TestCamelCaseFieldNames(); + + protected override TestCamelCaseFieldNames MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestCamelCaseFieldNames(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestCamelCaseFieldNames.Descriptor; } + } + + public override TestCamelCaseFieldNames DefaultInstanceForType { + get { return TestCamelCaseFieldNames.DefaultInstance; } + } + + public override TestCamelCaseFieldNames BuildPartial() { + result.repeatedPrimitiveField_.MakeReadOnly(); + result.repeatedStringField_.MakeReadOnly(); + result.repeatedEnumField_.MakeReadOnly(); + result.repeatedMessageField_.MakeReadOnly(); + result.repeatedStringPieceField_.MakeReadOnly(); + result.repeatedCordField_.MakeReadOnly(); + TestCamelCaseFieldNames returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestCamelCaseFieldNames) { + return MergeFrom((TestCamelCaseFieldNames) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestCamelCaseFieldNames other) { + if (other == TestCamelCaseFieldNames.DefaultInstance) return this; + if (other.HasPrimitiveField) { + PrimitiveField = other.PrimitiveField; + } + if (other.HasStringField) { + StringField = other.StringField; + } + if (other.HasEnumField) { + EnumField = other.EnumField; + } + if (other.HasMessageField) { + MergeMessageField(other.MessageField); + } + if (other.HasStringPieceField) { + StringPieceField = other.StringPieceField; + } + if (other.HasCordField) { + CordField = other.CordField; + } + if (other.repeatedPrimitiveField_.Count != 0) { + base.AddRange(other.repeatedPrimitiveField_, result.repeatedPrimitiveField_); + } + if (other.repeatedStringField_.Count != 0) { + base.AddRange(other.repeatedStringField_, result.repeatedStringField_); + } + if (other.repeatedEnumField_.Count != 0) { + base.AddRange(other.repeatedEnumField_, result.repeatedEnumField_); + } + if (other.repeatedMessageField_.Count != 0) { + base.AddRange(other.repeatedMessageField_, result.repeatedMessageField_); + } + if (other.repeatedStringPieceField_.Count != 0) { + base.AddRange(other.repeatedStringPieceField_, result.repeatedStringPieceField_); + } + if (other.repeatedCordField_.Count != 0) { + base.AddRange(other.repeatedCordField_, result.repeatedCordField_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + PrimitiveField = input.ReadInt32(); + break; + } + case 18: { + StringField = input.ReadString(); + break; + } + case 24: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(3, (ulong) rawValue); + } else { + EnumField = (global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue; + } + break; + } + case 34: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + if (HasMessageField) { + subBuilder.MergeFrom(MessageField); + } + input.ReadMessage(subBuilder, extensionRegistry); + MessageField = subBuilder.BuildPartial(); + break; + } + case 42: { + StringPieceField = input.ReadString(); + break; + } + case 50: { + CordField = input.ReadString(); + break; + } + case 56: { + AddRepeatedPrimitiveField(input.ReadInt32()); + break; + } + case 66: { + AddRepeatedStringField(input.ReadString()); + break; + } + case 72: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.TestProtos.ForeignEnum), rawValue)) { + unknownFields.MergeVarintField(9, (ulong) rawValue); + } else { + AddRepeatedEnumField((global::Google.ProtocolBuffers.TestProtos.ForeignEnum) rawValue); + } + break; + } + case 82: { + global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddRepeatedMessageField(subBuilder.BuildPartial()); + break; + } + case 90: { + AddRepeatedStringPieceField(input.ReadString()); + break; + } + case 98: { + AddRepeatedCordField(input.ReadString()); + break; + } + } + } + } + + + public bool HasPrimitiveField { + get { return result.HasPrimitiveField; } + } + public int PrimitiveField { + get { return result.PrimitiveField; } + set { SetPrimitiveField(value); } + } + public Builder SetPrimitiveField(int value) { + result.hasPrimitiveField = true; + result.primitiveField_ = value; + return this; + } + public Builder ClearPrimitiveField() { + result.hasPrimitiveField = false; + result.primitiveField_ = 0; + return this; + } + + public bool HasStringField { + get { return result.HasStringField; } + } + public string StringField { + get { return result.StringField; } + set { SetStringField(value); } + } + public Builder SetStringField(string value) { + result.hasStringField = true; + result.stringField_ = value; + return this; + } + public Builder ClearStringField() { + result.hasStringField = false; + result.stringField_ = ""; + return this; + } + + public bool HasEnumField { + get { return result.HasEnumField; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum EnumField { + get { return result.EnumField; } + set { SetEnumField(value); } + } + public Builder SetEnumField(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.hasEnumField = true; + result.enumField_ = value; + return this; + } + public Builder ClearEnumField() { + result.hasEnumField = false; + result.enumField_ = global::Google.ProtocolBuffers.TestProtos.ForeignEnum.FOREIGN_FOO; + return this; + } + + public bool HasMessageField { + get { return result.HasMessageField; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage MessageField { + get { return result.MessageField; } + set { SetMessageField(value); } + } + public Builder SetMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.hasMessageField = true; + result.messageField_ = value; + return this; + } + public Builder SetMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.hasMessageField = true; + result.messageField_ = builderForValue.Build(); + return this; + } + public Builder MergeMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + if (result.HasMessageField && + result.messageField_ != global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance) { + result.messageField_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.CreateBuilder(result.messageField_).MergeFrom(value).BuildPartial(); + } else { + result.messageField_ = value; + } + result.hasMessageField = true; + return this; + } + public Builder ClearMessageField() { + result.hasMessageField = false; + result.messageField_ = global::Google.ProtocolBuffers.TestProtos.ForeignMessage.DefaultInstance; + return this; + } + + public bool HasStringPieceField { + get { return result.HasStringPieceField; } + } + public string StringPieceField { + get { return result.StringPieceField; } + set { SetStringPieceField(value); } + } + public Builder SetStringPieceField(string value) { + result.hasStringPieceField = true; + result.stringPieceField_ = value; + return this; + } + public Builder ClearStringPieceField() { + result.hasStringPieceField = false; + result.stringPieceField_ = ""; + return this; + } + + public bool HasCordField { + get { return result.HasCordField; } + } + public string CordField { + get { return result.CordField; } + set { SetCordField(value); } + } + public Builder SetCordField(string value) { + result.hasCordField = true; + result.cordField_ = value; + return this; + } + public Builder ClearCordField() { + result.hasCordField = false; + result.cordField_ = ""; + return this; + } + + public scg::IList<int> RepeatedPrimitiveFieldList { + get { return result.repeatedPrimitiveField_; } + } + public int RepeatedPrimitiveFieldCount { + get { return result.RepeatedPrimitiveFieldCount; } + } + public int GetRepeatedPrimitiveField(int index) { + return result.GetRepeatedPrimitiveField(index); + } + public Builder SetRepeatedPrimitiveField(int index, int value) { + result.repeatedPrimitiveField_[index] = value; + return this; + } + public Builder AddRepeatedPrimitiveField(int value) { + result.repeatedPrimitiveField_.Add(value); + return this; + } + public Builder AddRangeRepeatedPrimitiveField(scg::IEnumerable<int> values) { + base.AddRange(values, result.repeatedPrimitiveField_); + return this; + } + public Builder ClearRepeatedPrimitiveField() { + result.repeatedPrimitiveField_.Clear(); + return this; + } + + public scg::IList<string> RepeatedStringFieldList { + get { return result.repeatedStringField_; } + } + public int RepeatedStringFieldCount { + get { return result.RepeatedStringFieldCount; } + } + public string GetRepeatedStringField(int index) { + return result.GetRepeatedStringField(index); + } + public Builder SetRepeatedStringField(int index, string value) { + result.repeatedStringField_[index] = value; + return this; + } + public Builder AddRepeatedStringField(string value) { + result.repeatedStringField_.Add(value); + return this; + } + public Builder AddRangeRepeatedStringField(scg::IEnumerable<string> values) { + base.AddRange(values, result.repeatedStringField_); + return this; + } + public Builder ClearRepeatedStringField() { + result.repeatedStringField_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> RepeatedEnumFieldList { + get { return result.repeatedEnumField_; } + } + public int RepeatedEnumFieldCount { + get { return result.RepeatedEnumFieldCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignEnum GetRepeatedEnumField(int index) { + return result.GetRepeatedEnumField(index); + } + public Builder SetRepeatedEnumField(int index, global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.repeatedEnumField_[index] = value; + return this; + } + public Builder AddRepeatedEnumField(global::Google.ProtocolBuffers.TestProtos.ForeignEnum value) { + result.repeatedEnumField_.Add(value); + return this; + } + public Builder AddRangeRepeatedEnumField(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.ForeignEnum> values) { + base.AddRange(values, result.repeatedEnumField_); + return this; + } + public Builder ClearRepeatedEnumField() { + result.repeatedEnumField_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> RepeatedMessageFieldList { + get { return result.repeatedMessageField_; } + } + public int RepeatedMessageFieldCount { + get { return result.RepeatedMessageFieldCount; } + } + public global::Google.ProtocolBuffers.TestProtos.ForeignMessage GetRepeatedMessageField(int index) { + return result.GetRepeatedMessageField(index); + } + public Builder SetRepeatedMessageField(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.repeatedMessageField_[index] = value; + return this; + } + public Builder SetRepeatedMessageField(int index, global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.repeatedMessageField_[index] = builderForValue.Build(); + return this; + } + public Builder AddRepeatedMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage value) { + result.repeatedMessageField_.Add(value); + return this; + } + public Builder AddRepeatedMessageField(global::Google.ProtocolBuffers.TestProtos.ForeignMessage.Builder builderForValue) { + result.repeatedMessageField_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeRepeatedMessageField(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.ForeignMessage> values) { + base.AddRange(values, result.repeatedMessageField_); + return this; + } + public Builder ClearRepeatedMessageField() { + result.repeatedMessageField_.Clear(); + return this; + } + + public scg::IList<string> RepeatedStringPieceFieldList { + get { return result.repeatedStringPieceField_; } + } + public int RepeatedStringPieceFieldCount { + get { return result.RepeatedStringPieceFieldCount; } + } + public string GetRepeatedStringPieceField(int index) { + return result.GetRepeatedStringPieceField(index); + } + public Builder SetRepeatedStringPieceField(int index, string value) { + result.repeatedStringPieceField_[index] = value; + return this; + } + public Builder AddRepeatedStringPieceField(string value) { + result.repeatedStringPieceField_.Add(value); + return this; + } + public Builder AddRangeRepeatedStringPieceField(scg::IEnumerable<string> values) { + base.AddRange(values, result.repeatedStringPieceField_); + return this; + } + public Builder ClearRepeatedStringPieceField() { + result.repeatedStringPieceField_.Clear(); + return this; + } + + public scg::IList<string> RepeatedCordFieldList { + get { return result.repeatedCordField_; } + } + public int RepeatedCordFieldCount { + get { return result.RepeatedCordFieldCount; } + } + public string GetRepeatedCordField(int index) { + return result.GetRepeatedCordField(index); + } + public Builder SetRepeatedCordField(int index, string value) { + result.repeatedCordField_[index] = value; + return this; + } + public Builder AddRepeatedCordField(string value) { + result.repeatedCordField_.Add(value); + return this; + } + public Builder AddRangeRepeatedCordField(scg::IEnumerable<string> values) { + base.AddRange(values, result.repeatedCordField_); + return this; + } + public Builder ClearRepeatedCordField() { + result.repeatedCordField_.Clear(); + return this; + } + } + } + + public sealed partial class TestFieldOrderings : pb::ExtendableMessage<TestFieldOrderings, TestFieldOrderings.Builder> { + private static readonly TestFieldOrderings defaultInstance = new Builder().BuildPartial(); + public static TestFieldOrderings DefaultInstance { + get { return defaultInstance; } + } + + public override TestFieldOrderings DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestFieldOrderings ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestFieldOrderings__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestFieldOrderings, TestFieldOrderings.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestFieldOrderings__FieldAccessorTable; } + } + + private bool hasMyString; + private string myString_ = ""; + public bool HasMyString { + get { return hasMyString; } + } + public string MyString { + get { return myString_; } + } + + private bool hasMyInt; + private long myInt_ = 0L; + public bool HasMyInt { + get { return hasMyInt; } + } + public long MyInt { + get { return myInt_; } + } + + private bool hasMyFloat; + private float myFloat_ = 0F; + public bool HasMyFloat { + get { return hasMyFloat; } + } + public float MyFloat { + get { return myFloat_; } + } + + public override bool IsInitialized { + get { + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<TestFieldOrderings, TestFieldOrderings.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + if (HasMyInt) { + output.WriteInt64(1, MyInt); + } + extensionWriter.WriteUntil(11, output); + if (HasMyString) { + output.WriteString(11, MyString); + } + extensionWriter.WriteUntil(101, output); + if (HasMyFloat) { + output.WriteFloat(101, MyFloat); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasMyString) { + size += pb::CodedOutputStream.ComputeStringSize(11, MyString); + } + if (HasMyInt) { + size += pb::CodedOutputStream.ComputeInt64Size(1, MyInt); + } + if (HasMyFloat) { + size += pb::CodedOutputStream.ComputeFloatSize(101, MyFloat); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestFieldOrderings ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestFieldOrderings ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestFieldOrderings prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<TestFieldOrderings, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestFieldOrderings result = new TestFieldOrderings(); + + protected override TestFieldOrderings MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestFieldOrderings(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestFieldOrderings.Descriptor; } + } + + public override TestFieldOrderings DefaultInstanceForType { + get { return TestFieldOrderings.DefaultInstance; } + } + + public override TestFieldOrderings BuildPartial() { + TestFieldOrderings returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestFieldOrderings) { + return MergeFrom((TestFieldOrderings) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestFieldOrderings other) { + if (other == TestFieldOrderings.DefaultInstance) return this; + if (other.HasMyString) { + MyString = other.MyString; + } + if (other.HasMyInt) { + MyInt = other.MyInt; + } + if (other.HasMyFloat) { + MyFloat = other.MyFloat; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + MyInt = input.ReadInt64(); + break; + } + case 90: { + MyString = input.ReadString(); + break; + } + case 813: { + MyFloat = input.ReadFloat(); + break; + } + } + } + } + + + public bool HasMyString { + get { return result.HasMyString; } + } + public string MyString { + get { return result.MyString; } + set { SetMyString(value); } + } + public Builder SetMyString(string value) { + result.hasMyString = true; + result.myString_ = value; + return this; + } + public Builder ClearMyString() { + result.hasMyString = false; + result.myString_ = ""; + return this; + } + + public bool HasMyInt { + get { return result.HasMyInt; } + } + public long MyInt { + get { return result.MyInt; } + set { SetMyInt(value); } + } + public Builder SetMyInt(long value) { + result.hasMyInt = true; + result.myInt_ = value; + return this; + } + public Builder ClearMyInt() { + result.hasMyInt = false; + result.myInt_ = 0L; + return this; + } + + public bool HasMyFloat { + get { return result.HasMyFloat; } + } + public float MyFloat { + get { return result.MyFloat; } + set { SetMyFloat(value); } + } + public Builder SetMyFloat(float value) { + result.hasMyFloat = true; + result.myFloat_ = value; + return this; + } + public Builder ClearMyFloat() { + result.hasMyFloat = false; + result.myFloat_ = 0F; + return this; + } + } + } + + public sealed partial class TestExtremeDefaultValues : pb::GeneratedMessage<TestExtremeDefaultValues, TestExtremeDefaultValues.Builder> { + private static readonly TestExtremeDefaultValues defaultInstance = new Builder().BuildPartial(); + public static TestExtremeDefaultValues DefaultInstance { + get { return defaultInstance; } + } + + public override TestExtremeDefaultValues DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override TestExtremeDefaultValues ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestExtremeDefaultValues__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<TestExtremeDefaultValues, TestExtremeDefaultValues.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_TestExtremeDefaultValues__FieldAccessorTable; } + } + + private bool hasEscapedBytes; + private pb::ByteString escapedBytes_ = (pb::ByteString) global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Descriptor.Fields[0].DefaultValue; + public bool HasEscapedBytes { + get { return hasEscapedBytes; } + } + public pb::ByteString EscapedBytes { + get { return escapedBytes_; } + } + + private bool hasLargeUint32; + private uint largeUint32_ = 4294967295; + public bool HasLargeUint32 { + get { return hasLargeUint32; } + } + public uint LargeUint32 { + get { return largeUint32_; } + } + + private bool hasLargeUint64; + private ulong largeUint64_ = 18446744073709551615UL; + public bool HasLargeUint64 { + get { return hasLargeUint64; } + } + public ulong LargeUint64 { + get { return largeUint64_; } + } + + private bool hasSmallInt32; + private int smallInt32_ = -2147483647; + public bool HasSmallInt32 { + get { return hasSmallInt32; } + } + public int SmallInt32 { + get { return smallInt32_; } + } + + private bool hasSmallInt64; + private long smallInt64_ = -9223372036854775807L; + public bool HasSmallInt64 { + get { return hasSmallInt64; } + } + public long SmallInt64 { + get { return smallInt64_; } + } + + private bool hasUtf8String; + private string utf8String_ = (string) global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Descriptor.Fields[5].DefaultValue; + public bool HasUtf8String { + get { return hasUtf8String; } + } + public string Utf8String { + get { return utf8String_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasEscapedBytes) { + output.WriteBytes(1, EscapedBytes); + } + if (HasLargeUint32) { + output.WriteUInt32(2, LargeUint32); + } + if (HasLargeUint64) { + output.WriteUInt64(3, LargeUint64); + } + if (HasSmallInt32) { + output.WriteInt32(4, SmallInt32); + } + if (HasSmallInt64) { + output.WriteInt64(5, SmallInt64); + } + if (HasUtf8String) { + output.WriteString(6, Utf8String); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasEscapedBytes) { + size += pb::CodedOutputStream.ComputeBytesSize(1, EscapedBytes); + } + if (HasLargeUint32) { + size += pb::CodedOutputStream.ComputeUInt32Size(2, LargeUint32); + } + if (HasLargeUint64) { + size += pb::CodedOutputStream.ComputeUInt64Size(3, LargeUint64); + } + if (HasSmallInt32) { + size += pb::CodedOutputStream.ComputeInt32Size(4, SmallInt32); + } + if (HasSmallInt64) { + size += pb::CodedOutputStream.ComputeInt64Size(5, SmallInt64); + } + if (HasUtf8String) { + size += pb::CodedOutputStream.ComputeStringSize(6, Utf8String); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static TestExtremeDefaultValues ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static TestExtremeDefaultValues ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(TestExtremeDefaultValues prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<TestExtremeDefaultValues, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + TestExtremeDefaultValues result = new TestExtremeDefaultValues(); + + protected override TestExtremeDefaultValues MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new TestExtremeDefaultValues(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return TestExtremeDefaultValues.Descriptor; } + } + + public override TestExtremeDefaultValues DefaultInstanceForType { + get { return TestExtremeDefaultValues.DefaultInstance; } + } + + public override TestExtremeDefaultValues BuildPartial() { + TestExtremeDefaultValues returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is TestExtremeDefaultValues) { + return MergeFrom((TestExtremeDefaultValues) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(TestExtremeDefaultValues other) { + if (other == TestExtremeDefaultValues.DefaultInstance) return this; + if (other.HasEscapedBytes) { + EscapedBytes = other.EscapedBytes; + } + if (other.HasLargeUint32) { + LargeUint32 = other.LargeUint32; + } + if (other.HasLargeUint64) { + LargeUint64 = other.LargeUint64; + } + if (other.HasSmallInt32) { + SmallInt32 = other.SmallInt32; + } + if (other.HasSmallInt64) { + SmallInt64 = other.SmallInt64; + } + if (other.HasUtf8String) { + Utf8String = other.Utf8String; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + EscapedBytes = input.ReadBytes(); + break; + } + case 16: { + LargeUint32 = input.ReadUInt32(); + break; + } + case 24: { + LargeUint64 = input.ReadUInt64(); + break; + } + case 32: { + SmallInt32 = input.ReadInt32(); + break; + } + case 40: { + SmallInt64 = input.ReadInt64(); + break; + } + case 50: { + Utf8String = input.ReadString(); + break; + } + } + } + } + + + public bool HasEscapedBytes { + get { return result.HasEscapedBytes; } + } + public pb::ByteString EscapedBytes { + get { return result.EscapedBytes; } + set { SetEscapedBytes(value); } + } + public Builder SetEscapedBytes(pb::ByteString value) { + result.hasEscapedBytes = true; + result.escapedBytes_ = value; + return this; + } + public Builder ClearEscapedBytes() { + result.hasEscapedBytes = false; + result.escapedBytes_ = (pb::ByteString) global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Descriptor.Fields[0].DefaultValue; + return this; + } + + public bool HasLargeUint32 { + get { return result.HasLargeUint32; } + } + public uint LargeUint32 { + get { return result.LargeUint32; } + set { SetLargeUint32(value); } + } + public Builder SetLargeUint32(uint value) { + result.hasLargeUint32 = true; + result.largeUint32_ = value; + return this; + } + public Builder ClearLargeUint32() { + result.hasLargeUint32 = false; + result.largeUint32_ = 4294967295; + return this; + } + + public bool HasLargeUint64 { + get { return result.HasLargeUint64; } + } + public ulong LargeUint64 { + get { return result.LargeUint64; } + set { SetLargeUint64(value); } + } + public Builder SetLargeUint64(ulong value) { + result.hasLargeUint64 = true; + result.largeUint64_ = value; + return this; + } + public Builder ClearLargeUint64() { + result.hasLargeUint64 = false; + result.largeUint64_ = 18446744073709551615UL; + return this; + } + + public bool HasSmallInt32 { + get { return result.HasSmallInt32; } + } + public int SmallInt32 { + get { return result.SmallInt32; } + set { SetSmallInt32(value); } + } + public Builder SetSmallInt32(int value) { + result.hasSmallInt32 = true; + result.smallInt32_ = value; + return this; + } + public Builder ClearSmallInt32() { + result.hasSmallInt32 = false; + result.smallInt32_ = -2147483647; + return this; + } + + public bool HasSmallInt64 { + get { return result.HasSmallInt64; } + } + public long SmallInt64 { + get { return result.SmallInt64; } + set { SetSmallInt64(value); } + } + public Builder SetSmallInt64(long value) { + result.hasSmallInt64 = true; + result.smallInt64_ = value; + return this; + } + public Builder ClearSmallInt64() { + result.hasSmallInt64 = false; + result.smallInt64_ = -9223372036854775807L; + return this; + } + + public bool HasUtf8String { + get { return result.HasUtf8String; } + } + public string Utf8String { + get { return result.Utf8String; } + set { SetUtf8String(value); } + } + public Builder SetUtf8String(string value) { + result.hasUtf8String = true; + result.utf8String_ = value; + return this; + } + public Builder ClearUtf8String() { + result.hasUtf8String = false; + result.utf8String_ = (string) global::Google.ProtocolBuffers.TestProtos.TestExtremeDefaultValues.Descriptor.Fields[5].DefaultValue; + return this; + } + } + } + + public sealed partial class FooRequest : pb::GeneratedMessage<FooRequest, FooRequest.Builder> { + private static readonly FooRequest defaultInstance = new Builder().BuildPartial(); + public static FooRequest DefaultInstance { + get { return defaultInstance; } + } + + public override FooRequest DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override FooRequest ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_FooRequest__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<FooRequest, FooRequest.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_FooRequest__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static FooRequest ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FooRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FooRequest ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FooRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FooRequest ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FooRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static FooRequest ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FooRequest ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(FooRequest prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<FooRequest, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + FooRequest result = new FooRequest(); + + protected override FooRequest MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new FooRequest(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return FooRequest.Descriptor; } + } + + public override FooRequest DefaultInstanceForType { + get { return FooRequest.DefaultInstance; } + } + + public override FooRequest BuildPartial() { + FooRequest returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is FooRequest) { + return MergeFrom((FooRequest) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(FooRequest other) { + if (other == FooRequest.DefaultInstance) return this; + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class FooResponse : pb::GeneratedMessage<FooResponse, FooResponse.Builder> { + private static readonly FooResponse defaultInstance = new Builder().BuildPartial(); + public static FooResponse DefaultInstance { + get { return defaultInstance; } + } + + public override FooResponse DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override FooResponse ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_FooResponse__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<FooResponse, FooResponse.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_FooResponse__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static FooResponse ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FooResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FooResponse ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FooResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FooResponse ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FooResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static FooResponse ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FooResponse ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(FooResponse prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<FooResponse, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + FooResponse result = new FooResponse(); + + protected override FooResponse MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new FooResponse(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return FooResponse.Descriptor; } + } + + public override FooResponse DefaultInstanceForType { + get { return FooResponse.DefaultInstance; } + } + + public override FooResponse BuildPartial() { + FooResponse returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is FooResponse) { + return MergeFrom((FooResponse) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(FooResponse other) { + if (other == FooResponse.DefaultInstance) return this; + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class BarRequest : pb::GeneratedMessage<BarRequest, BarRequest.Builder> { + private static readonly BarRequest defaultInstance = new Builder().BuildPartial(); + public static BarRequest DefaultInstance { + get { return defaultInstance; } + } + + public override BarRequest DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override BarRequest ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_BarRequest__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<BarRequest, BarRequest.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_BarRequest__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static BarRequest ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static BarRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static BarRequest ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static BarRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static BarRequest ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static BarRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static BarRequest ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static BarRequest ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(BarRequest prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<BarRequest, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + BarRequest result = new BarRequest(); + + protected override BarRequest MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new BarRequest(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return BarRequest.Descriptor; } + } + + public override BarRequest DefaultInstanceForType { + get { return BarRequest.DefaultInstance; } + } + + public override BarRequest BuildPartial() { + BarRequest returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is BarRequest) { + return MergeFrom((BarRequest) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(BarRequest other) { + if (other == BarRequest.DefaultInstance) return this; + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + public sealed partial class BarResponse : pb::GeneratedMessage<BarResponse, BarResponse.Builder> { + private static readonly BarResponse defaultInstance = new Builder().BuildPartial(); + public static BarResponse DefaultInstance { + get { return defaultInstance; } + } + + public override BarResponse DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override BarResponse ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_BarResponse__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<BarResponse, BarResponse.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.TestProtos.UnitTestProtoFile.internal__static_protobuf_unittest_BarResponse__FieldAccessorTable; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static BarResponse ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static BarResponse ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static BarResponse ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static BarResponse ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static BarResponse ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static BarResponse ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static BarResponse ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static BarResponse ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(BarResponse prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<BarResponse, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + BarResponse result = new BarResponse(); + + protected override BarResponse MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new BarResponse(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return BarResponse.Descriptor; } + } + + public override BarResponse DefaultInstanceForType { + get { return BarResponse.DefaultInstance; } + } + + public override BarResponse BuildPartial() { + BarResponse returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is BarResponse) { + return MergeFrom((BarResponse) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(BarResponse other) { + if (other == BarResponse.DefaultInstance) return this; + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + } + } + } + + } + } + + #endregion + + #region Services + public abstract class TestService : pb::IService { + public abstract void Foo( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.FooRequest request, + global::System.Action<global::Google.ProtocolBuffers.TestProtos.FooResponse> done); + public abstract void Bar( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.BarRequest request, + global::System.Action<global::Google.ProtocolBuffers.TestProtos.BarResponse> done); + + public static pbd::ServiceDescriptor Descriptor { + get { return UnitTestProtoFile.Descriptor.Services[0]; } + } + public pbd::ServiceDescriptor DescriptorForType { + get { return Descriptor; } + } + + public void CallMethod( + pbd::MethodDescriptor method, + pb::IRpcController controller, + pb::IMessage request, + global::System.Action<pb::IMessage> done) { + if (method.Service != Descriptor) { + throw new global::System.ArgumentException( + "Service.CallMethod() given method descriptor for wrong service type."); + } + switch(method.Index) { + case 0: + this.Foo(controller, (global::Google.ProtocolBuffers.TestProtos.FooRequest) request, + pb::RpcUtil.SpecializeCallback<global::Google.ProtocolBuffers.TestProtos.FooResponse>( + done)); + return; + case 1: + this.Bar(controller, (global::Google.ProtocolBuffers.TestProtos.BarRequest) request, + pb::RpcUtil.SpecializeCallback<global::Google.ProtocolBuffers.TestProtos.BarResponse>( + done)); + return; + default: + throw new global::System.InvalidOperationException("Can't get here."); + } + } + + public pb::IMessage GetRequestPrototype(pbd::MethodDescriptor method) { + if (method.Service != Descriptor) { + throw new global::System.ArgumentException( + "Service.GetRequestPrototype() given method descriptor for wrong service type."); + } + switch(method.Index) { + case 0: + return global::Google.ProtocolBuffers.TestProtos.FooRequest.DefaultInstance; + case 1: + return global::Google.ProtocolBuffers.TestProtos.BarRequest.DefaultInstance; + default: + throw new global::System.InvalidOperationException("Can't get here."); + } + } + + public pb::IMessage GetResponsePrototype(pbd::MethodDescriptor method) { + if (method.Service != Descriptor) { + throw new global::System.ArgumentException( + "Service.GetResponsePrototype() given method descriptor for wrong service type."); + } + switch(method.Index) { + case 0: + return global::Google.ProtocolBuffers.TestProtos.FooResponse.DefaultInstance; + case 1: + return global::Google.ProtocolBuffers.TestProtos.BarResponse.DefaultInstance; + default: + throw new global::System.InvalidOperationException("Can't get here."); + } + } + + public static Stub CreateStub(pb::IRpcChannel channel) { + return new Stub(channel); + } + + public class Stub : global::Google.ProtocolBuffers.TestProtos.TestService { + internal Stub(pb::IRpcChannel channel) { + this.channel = channel; + } + + private readonly pb::IRpcChannel channel; + + public pb::IRpcChannel Channel { + get { return channel; } + } + + public override void Foo( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.FooRequest request, + global::System.Action<global::Google.ProtocolBuffers.TestProtos.FooResponse> done) { + channel.CallMethod(Descriptor.Methods[0], + controller, request, global::Google.ProtocolBuffers.TestProtos.FooResponse.DefaultInstance, + pb::RpcUtil.GeneralizeCallback<global::Google.ProtocolBuffers.TestProtos.FooResponse, global::Google.ProtocolBuffers.TestProtos.FooResponse.Builder>(done, global::Google.ProtocolBuffers.TestProtos.FooResponse.DefaultInstance)); + } + + public override void Bar( + pb::IRpcController controller, + global::Google.ProtocolBuffers.TestProtos.BarRequest request, + global::System.Action<global::Google.ProtocolBuffers.TestProtos.BarResponse> done) { + channel.CallMethod(Descriptor.Methods[1], + controller, request, global::Google.ProtocolBuffers.TestProtos.BarResponse.DefaultInstance, + pb::RpcUtil.GeneralizeCallback<global::Google.ProtocolBuffers.TestProtos.BarResponse, global::Google.ProtocolBuffers.TestProtos.BarResponse.Builder>(done, global::Google.ProtocolBuffers.TestProtos.BarResponse.DefaultInstance)); + } + } + } + #endregion + +} diff --git a/src/ProtocolBuffers.Test/TestUtil.cs b/src/ProtocolBuffers.Test/TestUtil.cs new file mode 100644 index 00000000..70dd3c88 --- /dev/null +++ b/src/ProtocolBuffers.Test/TestUtil.cs @@ -0,0 +1,1370 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + internal static class TestUtil { + + private static string testDataDirectory; + private static ByteString goldenMessage = null; + + internal static string TestDataDirectory { + get { + if (testDataDirectory != null) { + return testDataDirectory; + } + + DirectoryInfo ancestor = new DirectoryInfo("."); + // Search each parent directory looking for "testdata". + while (ancestor != null) { + string candidate = Path.Combine(ancestor.FullName, "testdata"); + if (Directory.Exists(candidate)) { + return candidate; + } + ancestor = ancestor.Parent; + } + // TODO(jonskeet): Come up with a better exception to throw + throw new Exception("Unable to find directory containing test files"); + } + } + + internal static ByteString GoldenMessage { + get { + if (goldenMessage == null) { + goldenMessage = ReadBytesFromFile("golden_message"); + } + return goldenMessage; + } + } + + /// <summary> + /// Creates an unmodifiable ExtensionRegistry containing all the extensions + /// of TestAllExtensions. + /// </summary> + /// <returns></returns> + internal static ExtensionRegistry CreateExtensionRegistry() { + ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); + RegisterAllExtensions(registry); + return registry.AsReadOnly(); + } + + /// <summary> + /// Registers all of the extensions in TestAllExtensions with the given + /// ExtensionRegistry. + /// </summary> + internal static void RegisterAllExtensions(ExtensionRegistry registry) { + registry.Add(UnitTestProtoFile.OptionalInt32Extension); + registry.Add(UnitTestProtoFile.OptionalInt64Extension); + registry.Add(UnitTestProtoFile.OptionalUint32Extension); + registry.Add(UnitTestProtoFile.OptionalUint64Extension); + registry.Add(UnitTestProtoFile.OptionalSint32Extension); + registry.Add(UnitTestProtoFile.OptionalSint64Extension); + registry.Add(UnitTestProtoFile.OptionalFixed32Extension); + registry.Add(UnitTestProtoFile.OptionalFixed64Extension); + registry.Add(UnitTestProtoFile.OptionalSfixed32Extension); + registry.Add(UnitTestProtoFile.OptionalSfixed64Extension); + registry.Add(UnitTestProtoFile.OptionalFloatExtension); + registry.Add(UnitTestProtoFile.OptionalDoubleExtension); + registry.Add(UnitTestProtoFile.OptionalBoolExtension); + registry.Add(UnitTestProtoFile.OptionalStringExtension); + registry.Add(UnitTestProtoFile.OptionalBytesExtension); + registry.Add(UnitTestProtoFile.OptionalGroupExtension); + registry.Add(UnitTestProtoFile.OptionalNestedMessageExtension); + registry.Add(UnitTestProtoFile.OptionalForeignMessageExtension); + registry.Add(UnitTestProtoFile.OptionalImportMessageExtension); + registry.Add(UnitTestProtoFile.OptionalNestedEnumExtension); + registry.Add(UnitTestProtoFile.OptionalForeignEnumExtension); + registry.Add(UnitTestProtoFile.OptionalImportEnumExtension); + registry.Add(UnitTestProtoFile.OptionalStringPieceExtension); + registry.Add(UnitTestProtoFile.OptionalCordExtension); + + registry.Add(UnitTestProtoFile.RepeatedInt32Extension); + registry.Add(UnitTestProtoFile.RepeatedInt64Extension); + registry.Add(UnitTestProtoFile.RepeatedUint32Extension); + registry.Add(UnitTestProtoFile.RepeatedUint64Extension); + registry.Add(UnitTestProtoFile.RepeatedSint32Extension); + registry.Add(UnitTestProtoFile.RepeatedSint64Extension); + registry.Add(UnitTestProtoFile.RepeatedFixed32Extension); + registry.Add(UnitTestProtoFile.RepeatedFixed64Extension); + registry.Add(UnitTestProtoFile.RepeatedSfixed32Extension); + registry.Add(UnitTestProtoFile.RepeatedSfixed64Extension); + registry.Add(UnitTestProtoFile.RepeatedFloatExtension); + registry.Add(UnitTestProtoFile.RepeatedDoubleExtension); + registry.Add(UnitTestProtoFile.RepeatedBoolExtension); + registry.Add(UnitTestProtoFile.RepeatedStringExtension); + registry.Add(UnitTestProtoFile.RepeatedBytesExtension); + registry.Add(UnitTestProtoFile.RepeatedGroupExtension); + registry.Add(UnitTestProtoFile.RepeatedNestedMessageExtension); + registry.Add(UnitTestProtoFile.RepeatedForeignMessageExtension); + registry.Add(UnitTestProtoFile.RepeatedImportMessageExtension); + registry.Add(UnitTestProtoFile.RepeatedNestedEnumExtension); + registry.Add(UnitTestProtoFile.RepeatedForeignEnumExtension); + registry.Add(UnitTestProtoFile.RepeatedImportEnumExtension); + registry.Add(UnitTestProtoFile.RepeatedStringPieceExtension); + registry.Add(UnitTestProtoFile.RepeatedCordExtension); + + registry.Add(UnitTestProtoFile.DefaultInt32Extension); + registry.Add(UnitTestProtoFile.DefaultInt64Extension); + registry.Add(UnitTestProtoFile.DefaultUint32Extension); + registry.Add(UnitTestProtoFile.DefaultUint64Extension); + registry.Add(UnitTestProtoFile.DefaultSint32Extension); + registry.Add(UnitTestProtoFile.DefaultSint64Extension); + registry.Add(UnitTestProtoFile.DefaultFixed32Extension); + registry.Add(UnitTestProtoFile.DefaultFixed64Extension); + registry.Add(UnitTestProtoFile.DefaultSfixed32Extension); + registry.Add(UnitTestProtoFile.DefaultSfixed64Extension); + registry.Add(UnitTestProtoFile.DefaultFloatExtension); + registry.Add(UnitTestProtoFile.DefaultDoubleExtension); + registry.Add(UnitTestProtoFile.DefaultBoolExtension); + registry.Add(UnitTestProtoFile.DefaultStringExtension); + registry.Add(UnitTestProtoFile.DefaultBytesExtension); + registry.Add(UnitTestProtoFile.DefaultNestedEnumExtension); + registry.Add(UnitTestProtoFile.DefaultForeignEnumExtension); + registry.Add(UnitTestProtoFile.DefaultImportEnumExtension); + registry.Add(UnitTestProtoFile.DefaultStringPieceExtension); + registry.Add(UnitTestProtoFile.DefaultCordExtension); + } + + internal static string ReadTextFromFile(string filePath) { + return ReadBytesFromFile(filePath).ToStringUtf8(); + } + + internal static ByteString ReadBytesFromFile(String filename) { + byte[] data = File.ReadAllBytes(Path.Combine(TestDataDirectory, filename)); + return ByteString.CopyFrom(data); + } + + /// <summary> + /// Helper to convert a String to ByteString. + /// </summary> + internal static ByteString ToBytes(String str) { + return ByteString.CopyFrom(Encoding.UTF8.GetBytes(str)); + } + + internal static TestAllTypes GetAllSet() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + SetAllFields(builder); + return builder.Build(); + } + + /// <summary> + /// Sets every field of the specified message to the values expected by + /// AssertAllFieldsSet. + /// </summary> + internal static void SetAllFields(TestAllTypes.Builder message) { + message.SetOptionalInt32(101); + message.SetOptionalInt64(102); + message.SetOptionalUint32(103); + message.SetOptionalUint64(104); + message.SetOptionalSint32(105); + message.SetOptionalSint64(106); + message.SetOptionalFixed32(107); + message.SetOptionalFixed64(108); + message.SetOptionalSfixed32(109); + message.SetOptionalSfixed64(110); + message.SetOptionalFloat(111); + message.SetOptionalDouble(112); + message.SetOptionalBool(true); + message.SetOptionalString("115"); + message.SetOptionalBytes(ToBytes("116")); + + message.SetOptionalGroup(TestAllTypes.Types.OptionalGroup.CreateBuilder().SetA(117).Build()); + message.SetOptionalNestedMessage(TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(118).Build()); + message.SetOptionalForeignMessage(ForeignMessage.CreateBuilder().SetC(119).Build()); + message.SetOptionalImportMessage(ImportMessage.CreateBuilder().SetD(120).Build()); + + message.SetOptionalNestedEnum(TestAllTypes.Types.NestedEnum.BAZ); + message.SetOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ); + message.SetOptionalImportEnum(ImportEnum.IMPORT_BAZ); + + message.SetOptionalStringPiece("124"); + message.SetOptionalCord("125"); + + // ----------------------------------------------------------------- + + message.AddRepeatedInt32(201); + message.AddRepeatedInt64(202); + message.AddRepeatedUint32(203); + message.AddRepeatedUint64(204); + message.AddRepeatedSint32(205); + message.AddRepeatedSint64(206); + message.AddRepeatedFixed32(207); + message.AddRepeatedFixed64(208); + message.AddRepeatedSfixed32(209); + message.AddRepeatedSfixed64(210); + message.AddRepeatedFloat(211); + message.AddRepeatedDouble(212); + message.AddRepeatedBool(true); + message.AddRepeatedString("215"); + message.AddRepeatedBytes(ToBytes("216")); + + message.AddRepeatedGroup(TestAllTypes.Types.RepeatedGroup.CreateBuilder().SetA(217).Build()); + message.AddRepeatedNestedMessage(TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(218).Build()); + message.AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(219).Build()); + message.AddRepeatedImportMessage(ImportMessage.CreateBuilder().SetD(220).Build()); + + message.AddRepeatedNestedEnum(TestAllTypes.Types.NestedEnum.BAR); + message.AddRepeatedForeignEnum(ForeignEnum.FOREIGN_BAR); + message.AddRepeatedImportEnum(ImportEnum.IMPORT_BAR); + + message.AddRepeatedStringPiece("224"); + message.AddRepeatedCord("225"); + + // Add a second one of each field. + message.AddRepeatedInt32(301); + message.AddRepeatedInt64(302); + message.AddRepeatedUint32(303); + message.AddRepeatedUint64(304); + message.AddRepeatedSint32(305); + message.AddRepeatedSint64(306); + message.AddRepeatedFixed32(307); + message.AddRepeatedFixed64(308); + message.AddRepeatedSfixed32(309); + message.AddRepeatedSfixed64(310); + message.AddRepeatedFloat(311); + message.AddRepeatedDouble(312); + message.AddRepeatedBool(false); + message.AddRepeatedString("315"); + message.AddRepeatedBytes(ToBytes("316")); + + message.AddRepeatedGroup(TestAllTypes.Types.RepeatedGroup.CreateBuilder().SetA(317).Build()); + message.AddRepeatedNestedMessage(TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(318).Build()); + message.AddRepeatedForeignMessage(ForeignMessage.CreateBuilder().SetC(319).Build()); + message.AddRepeatedImportMessage(ImportMessage.CreateBuilder().SetD(320).Build()); + + message.AddRepeatedNestedEnum(TestAllTypes.Types.NestedEnum.BAZ); + message.AddRepeatedForeignEnum(ForeignEnum.FOREIGN_BAZ); + message.AddRepeatedImportEnum(ImportEnum.IMPORT_BAZ); + + message.AddRepeatedStringPiece("324"); + message.AddRepeatedCord("325"); + + // ----------------------------------------------------------------- + + message.SetDefaultInt32(401); + message.SetDefaultInt64(402); + message.SetDefaultUint32(403); + message.SetDefaultUint64(404); + message.SetDefaultSint32(405); + message.SetDefaultSint64(406); + message.SetDefaultFixed32(407); + message.SetDefaultFixed64(408); + message.SetDefaultSfixed32(409); + message.SetDefaultSfixed64(410); + message.SetDefaultFloat(411); + message.SetDefaultDouble(412); + message.SetDefaultBool(false); + message.SetDefaultString("415"); + message.SetDefaultBytes(ToBytes("416")); + + message.SetDefaultNestedEnum(TestAllTypes.Types.NestedEnum.FOO); + message.SetDefaultForeignEnum(ForeignEnum.FOREIGN_FOO); + message.SetDefaultImportEnum(ImportEnum.IMPORT_FOO); + + message.SetDefaultStringPiece("424"); + message.SetDefaultCord("425"); + } + + /// <summary> + /// Asserts that all fields of the specified message are set to the values + /// assigned by SetAllFields. + /// </summary> + internal static void AssertAllFieldsSet(TestAllTypes message) { + Assert.IsTrue(message.HasOptionalInt32); + Assert.IsTrue(message.HasOptionalInt64); + Assert.IsTrue(message.HasOptionalUint32); + Assert.IsTrue(message.HasOptionalUint64); + Assert.IsTrue(message.HasOptionalSint32); + Assert.IsTrue(message.HasOptionalSint64); + Assert.IsTrue(message.HasOptionalFixed32); + Assert.IsTrue(message.HasOptionalFixed64); + Assert.IsTrue(message.HasOptionalSfixed32); + Assert.IsTrue(message.HasOptionalSfixed64); + Assert.IsTrue(message.HasOptionalFloat); + Assert.IsTrue(message.HasOptionalDouble); + Assert.IsTrue(message.HasOptionalBool); + Assert.IsTrue(message.HasOptionalString); + Assert.IsTrue(message.HasOptionalBytes); + + Assert.IsTrue(message.HasOptionalGroup); + Assert.IsTrue(message.HasOptionalNestedMessage); + Assert.IsTrue(message.HasOptionalForeignMessage); + Assert.IsTrue(message.HasOptionalImportMessage); + + Assert.IsTrue(message.OptionalGroup.HasA); + Assert.IsTrue(message.OptionalNestedMessage.HasBb); + Assert.IsTrue(message.OptionalForeignMessage.HasC); + Assert.IsTrue(message.OptionalImportMessage.HasD); + + Assert.IsTrue(message.HasOptionalNestedEnum); + Assert.IsTrue(message.HasOptionalForeignEnum); + Assert.IsTrue(message.HasOptionalImportEnum); + + Assert.IsTrue(message.HasOptionalStringPiece); + Assert.IsTrue(message.HasOptionalCord); + + Assert.AreEqual(101, message.OptionalInt32); + Assert.AreEqual(102, message.OptionalInt64); + Assert.AreEqual(103, message.OptionalUint32); + Assert.AreEqual(104, message.OptionalUint64); + Assert.AreEqual(105, message.OptionalSint32); + Assert.AreEqual(106, message.OptionalSint64); + Assert.AreEqual(107, message.OptionalFixed32); + Assert.AreEqual(108, message.OptionalFixed64); + Assert.AreEqual(109, message.OptionalSfixed32); + Assert.AreEqual(110, message.OptionalSfixed64); + Assert.AreEqual(111, message.OptionalFloat); + Assert.AreEqual(112, message.OptionalDouble); + Assert.AreEqual(true, message.OptionalBool); + Assert.AreEqual("115", message.OptionalString); + Assert.AreEqual(ToBytes("116"), message.OptionalBytes); + + Assert.AreEqual(117, message.OptionalGroup.A); + Assert.AreEqual(118, message.OptionalNestedMessage.Bb); + Assert.AreEqual(119, message.OptionalForeignMessage.C); + Assert.AreEqual(120, message.OptionalImportMessage.D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.OptionalNestedEnum); + Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.OptionalForeignEnum); + Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.OptionalImportEnum); + + Assert.AreEqual("124", message.OptionalStringPiece); + Assert.AreEqual("125", message.OptionalCord); + + // ----------------------------------------------------------------- + + Assert.AreEqual(2, message.RepeatedInt32Count); + Assert.AreEqual(2, message.RepeatedInt64Count); + Assert.AreEqual(2, message.RepeatedUint32Count); + Assert.AreEqual(2, message.RepeatedUint64Count); + Assert.AreEqual(2, message.RepeatedSint32Count); + Assert.AreEqual(2, message.RepeatedSint64Count); + Assert.AreEqual(2, message.RepeatedFixed32Count); + Assert.AreEqual(2, message.RepeatedFixed64Count); + Assert.AreEqual(2, message.RepeatedSfixed32Count); + Assert.AreEqual(2, message.RepeatedSfixed64Count); + Assert.AreEqual(2, message.RepeatedFloatCount); + Assert.AreEqual(2, message.RepeatedDoubleCount); + Assert.AreEqual(2, message.RepeatedBoolCount); + Assert.AreEqual(2, message.RepeatedStringCount); + Assert.AreEqual(2, message.RepeatedBytesCount); + + Assert.AreEqual(2, message.RepeatedGroupCount ); + Assert.AreEqual(2, message.RepeatedNestedMessageCount ); + Assert.AreEqual(2, message.RepeatedForeignMessageCount); + Assert.AreEqual(2, message.RepeatedImportMessageCount ); + Assert.AreEqual(2, message.RepeatedNestedEnumCount ); + Assert.AreEqual(2, message.RepeatedForeignEnumCount ); + Assert.AreEqual(2, message.RepeatedImportEnumCount ); + + Assert.AreEqual(2, message.RepeatedStringPieceCount); + Assert.AreEqual(2, message.RepeatedCordCount); + + Assert.AreEqual(201, message.GetRepeatedInt32(0)); + Assert.AreEqual(202, message.GetRepeatedInt64(0)); + Assert.AreEqual(203, message.GetRepeatedUint32(0)); + Assert.AreEqual(204, message.GetRepeatedUint64(0)); + Assert.AreEqual(205, message.GetRepeatedSint32(0)); + Assert.AreEqual(206, message.GetRepeatedSint64(0)); + Assert.AreEqual(207, message.GetRepeatedFixed32(0)); + Assert.AreEqual(208, message.GetRepeatedFixed64(0)); + Assert.AreEqual(209, message.GetRepeatedSfixed32(0)); + Assert.AreEqual(210, message.GetRepeatedSfixed64(0)); + Assert.AreEqual(211, message.GetRepeatedFloat(0)); + Assert.AreEqual(212, message.GetRepeatedDouble(0)); + Assert.AreEqual(true , message.GetRepeatedBool(0)); + Assert.AreEqual("215", message.GetRepeatedString(0)); + Assert.AreEqual(ToBytes("216"), message.GetRepeatedBytes(0)); + + Assert.AreEqual(217, message.GetRepeatedGroup(0).A); + Assert.AreEqual(218, message.GetRepeatedNestedMessage (0).Bb); + Assert.AreEqual(219, message.GetRepeatedForeignMessage(0).C); + Assert.AreEqual(220, message.GetRepeatedImportMessage (0).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum (0)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); + + Assert.AreEqual("224", message.GetRepeatedStringPiece(0)); + Assert.AreEqual("225", message.GetRepeatedCord(0)); + + Assert.AreEqual(301, message.GetRepeatedInt32 (1)); + Assert.AreEqual(302, message.GetRepeatedInt64 (1)); + Assert.AreEqual(303, message.GetRepeatedUint32 (1)); + Assert.AreEqual(304, message.GetRepeatedUint64 (1)); + Assert.AreEqual(305, message.GetRepeatedSint32 (1)); + Assert.AreEqual(306, message.GetRepeatedSint64 (1)); + Assert.AreEqual(307, message.GetRepeatedFixed32 (1)); + Assert.AreEqual(308, message.GetRepeatedFixed64 (1)); + Assert.AreEqual(309, message.GetRepeatedSfixed32(1)); + Assert.AreEqual(310, message.GetRepeatedSfixed64(1)); + Assert.AreEqual(311, message.GetRepeatedFloat (1), 0.0); + Assert.AreEqual(312, message.GetRepeatedDouble (1), 0.0); + Assert.AreEqual(false, message.GetRepeatedBool (1)); + Assert.AreEqual("315", message.GetRepeatedString (1)); + Assert.AreEqual(ToBytes("316"), message.GetRepeatedBytes(1)); + + Assert.AreEqual(317, message.GetRepeatedGroup (1).A); + Assert.AreEqual(318, message.GetRepeatedNestedMessage (1).Bb); + Assert.AreEqual(319, message.GetRepeatedForeignMessage(1).C); + Assert.AreEqual(320, message.GetRepeatedImportMessage (1).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetRepeatedNestedEnum (1)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetRepeatedForeignEnum(1)); + Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetRepeatedImportEnum(1)); + + Assert.AreEqual("324", message.GetRepeatedStringPiece(1)); + Assert.AreEqual("325", message.GetRepeatedCord(1)); + + // ----------------------------------------------------------------- + + Assert.IsTrue(message.HasDefaultInt32 ); + Assert.IsTrue(message.HasDefaultInt64 ); + Assert.IsTrue(message.HasDefaultUint32 ); + Assert.IsTrue(message.HasDefaultUint64 ); + Assert.IsTrue(message.HasDefaultSint32 ); + Assert.IsTrue(message.HasDefaultSint64 ); + Assert.IsTrue(message.HasDefaultFixed32 ); + Assert.IsTrue(message.HasDefaultFixed64 ); + Assert.IsTrue(message.HasDefaultSfixed32); + Assert.IsTrue(message.HasDefaultSfixed64); + Assert.IsTrue(message.HasDefaultFloat ); + Assert.IsTrue(message.HasDefaultDouble ); + Assert.IsTrue(message.HasDefaultBool ); + Assert.IsTrue(message.HasDefaultString ); + Assert.IsTrue(message.HasDefaultBytes ); + + Assert.IsTrue(message.HasDefaultNestedEnum ); + Assert.IsTrue(message.HasDefaultForeignEnum); + Assert.IsTrue(message.HasDefaultImportEnum ); + + Assert.IsTrue(message.HasDefaultStringPiece); + Assert.IsTrue(message.HasDefaultCord); + + Assert.AreEqual(401, message.DefaultInt32); + Assert.AreEqual(402, message.DefaultInt64); + Assert.AreEqual(403, message.DefaultUint32); + Assert.AreEqual(404, message.DefaultUint64); + Assert.AreEqual(405, message.DefaultSint32); + Assert.AreEqual(406, message.DefaultSint64); + Assert.AreEqual(407, message.DefaultFixed32); + Assert.AreEqual(408, message.DefaultFixed64); + Assert.AreEqual(409, message.DefaultSfixed32); + Assert.AreEqual(410, message.DefaultSfixed64); + Assert.AreEqual(411, message.DefaultFloat); + Assert.AreEqual(412, message.DefaultDouble); + Assert.AreEqual(false, message.DefaultBool ); + Assert.AreEqual("415", message.DefaultString ); + Assert.AreEqual(ToBytes("416"), message.DefaultBytes); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.DefaultNestedEnum); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.DefaultForeignEnum); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.DefaultImportEnum); + + Assert.AreEqual("424", message.DefaultStringPiece); + Assert.AreEqual("425", message.DefaultCord); + } + + internal static void AssertClear(TestAllTypes message) { + // HasBlah() should initially be false for all optional fields. + Assert.IsFalse(message.HasOptionalInt32); + Assert.IsFalse(message.HasOptionalInt64); + Assert.IsFalse(message.HasOptionalUint32); + Assert.IsFalse(message.HasOptionalUint64); + Assert.IsFalse(message.HasOptionalSint32); + Assert.IsFalse(message.HasOptionalSint64); + Assert.IsFalse(message.HasOptionalFixed32); + Assert.IsFalse(message.HasOptionalFixed64); + Assert.IsFalse(message.HasOptionalSfixed32); + Assert.IsFalse(message.HasOptionalSfixed64); + Assert.IsFalse(message.HasOptionalFloat); + Assert.IsFalse(message.HasOptionalDouble); + Assert.IsFalse(message.HasOptionalBool); + Assert.IsFalse(message.HasOptionalString); + Assert.IsFalse(message.HasOptionalBytes); + + Assert.IsFalse(message.HasOptionalGroup); + Assert.IsFalse(message.HasOptionalNestedMessage); + Assert.IsFalse(message.HasOptionalForeignMessage); + Assert.IsFalse(message.HasOptionalImportMessage); + + Assert.IsFalse(message.HasOptionalNestedEnum); + Assert.IsFalse(message.HasOptionalForeignEnum); + Assert.IsFalse(message.HasOptionalImportEnum); + + Assert.IsFalse(message.HasOptionalStringPiece); + Assert.IsFalse(message.HasOptionalCord); + + // Optional fields without defaults are set to zero or something like it. + Assert.AreEqual(0, message.OptionalInt32); + Assert.AreEqual(0, message.OptionalInt64); + Assert.AreEqual(0, message.OptionalUint32); + Assert.AreEqual(0, message.OptionalUint64); + Assert.AreEqual(0, message.OptionalSint32); + Assert.AreEqual(0, message.OptionalSint64); + Assert.AreEqual(0, message.OptionalFixed32); + Assert.AreEqual(0, message.OptionalFixed64); + Assert.AreEqual(0, message.OptionalSfixed32); + Assert.AreEqual(0, message.OptionalSfixed64); + Assert.AreEqual(0, message.OptionalFloat); + Assert.AreEqual(0, message.OptionalDouble); + Assert.AreEqual(false, message.OptionalBool); + Assert.AreEqual("", message.OptionalString); + Assert.AreEqual(ByteString.Empty, message.OptionalBytes); + + // Embedded messages should also be clear. + Assert.IsFalse(message.OptionalGroup.HasA); + Assert.IsFalse(message.OptionalNestedMessage.HasBb); + Assert.IsFalse(message.OptionalForeignMessage.HasC); + Assert.IsFalse(message.OptionalImportMessage.HasD); + + Assert.AreEqual(0, message.OptionalGroup.A); + Assert.AreEqual(0, message.OptionalNestedMessage.Bb); + Assert.AreEqual(0, message.OptionalForeignMessage.C); + Assert.AreEqual(0, message.OptionalImportMessage.D); + + // Enums without defaults are set to the first value in the enum. + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.OptionalNestedEnum); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.OptionalForeignEnum); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.OptionalImportEnum); + + Assert.AreEqual("", message.OptionalStringPiece); + Assert.AreEqual("", message.OptionalCord); + + // Repeated fields are empty. + Assert.AreEqual(0, message.RepeatedInt32Count); + Assert.AreEqual(0, message.RepeatedInt64Count); + Assert.AreEqual(0, message.RepeatedUint32Count); + Assert.AreEqual(0, message.RepeatedUint64Count); + Assert.AreEqual(0, message.RepeatedSint32Count); + Assert.AreEqual(0, message.RepeatedSint64Count); + Assert.AreEqual(0, message.RepeatedFixed32Count); + Assert.AreEqual(0, message.RepeatedFixed64Count); + Assert.AreEqual(0, message.RepeatedSfixed32Count); + Assert.AreEqual(0, message.RepeatedSfixed64Count); + Assert.AreEqual(0, message.RepeatedFloatCount); + Assert.AreEqual(0, message.RepeatedDoubleCount); + Assert.AreEqual(0, message.RepeatedBoolCount); + Assert.AreEqual(0, message.RepeatedStringCount); + Assert.AreEqual(0, message.RepeatedBytesCount); + + Assert.AreEqual(0, message.RepeatedGroupCount); + Assert.AreEqual(0, message.RepeatedNestedMessageCount); + Assert.AreEqual(0, message.RepeatedForeignMessageCount); + Assert.AreEqual(0, message.RepeatedImportMessageCount); + Assert.AreEqual(0, message.RepeatedNestedEnumCount); + Assert.AreEqual(0, message.RepeatedForeignEnumCount); + Assert.AreEqual(0, message.RepeatedImportEnumCount); + + Assert.AreEqual(0, message.RepeatedStringPieceCount); + Assert.AreEqual(0, message.RepeatedCordCount); + + // HasBlah() should also be false for all default fields. + Assert.IsFalse(message.HasDefaultInt32); + Assert.IsFalse(message.HasDefaultInt64); + Assert.IsFalse(message.HasDefaultUint32); + Assert.IsFalse(message.HasDefaultUint64); + Assert.IsFalse(message.HasDefaultSint32); + Assert.IsFalse(message.HasDefaultSint64); + Assert.IsFalse(message.HasDefaultFixed32); + Assert.IsFalse(message.HasDefaultFixed64); + Assert.IsFalse(message.HasDefaultSfixed32); + Assert.IsFalse(message.HasDefaultSfixed64); + Assert.IsFalse(message.HasDefaultFloat); + Assert.IsFalse(message.HasDefaultDouble); + Assert.IsFalse(message.HasDefaultBool); + Assert.IsFalse(message.HasDefaultString); + Assert.IsFalse(message.HasDefaultBytes); + + Assert.IsFalse(message.HasDefaultNestedEnum); + Assert.IsFalse(message.HasDefaultForeignEnum); + Assert.IsFalse(message.HasDefaultImportEnum); + + Assert.IsFalse(message.HasDefaultStringPiece); + Assert.IsFalse(message.HasDefaultCord); + + // Fields with defaults have their default values (duh). + Assert.AreEqual(41, message.DefaultInt32); + Assert.AreEqual(42, message.DefaultInt64); + Assert.AreEqual(43, message.DefaultUint32); + Assert.AreEqual(44, message.DefaultUint64); + Assert.AreEqual(-45, message.DefaultSint32); + Assert.AreEqual(46, message.DefaultSint64); + Assert.AreEqual(47, message.DefaultFixed32); + Assert.AreEqual(48, message.DefaultFixed64); + Assert.AreEqual(49, message.DefaultSfixed32); + Assert.AreEqual(-50, message.DefaultSfixed64); + Assert.AreEqual(51.5, message.DefaultFloat, 0.0); + Assert.AreEqual(52e3, message.DefaultDouble, 0.0); + Assert.AreEqual(true, message.DefaultBool); + Assert.AreEqual("hello", message.DefaultString); + Assert.AreEqual(ToBytes("world"), message.DefaultBytes); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.DefaultNestedEnum); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.DefaultForeignEnum); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.DefaultImportEnum); + + Assert.AreEqual("abc", message.DefaultStringPiece); + Assert.AreEqual("123", message.DefaultCord); + } + + /// <summary> + /// Get a TestAllExtensions with all fields set as they would be by + /// SetAllExtensions(TestAllExtensions.Builder). + /// </summary> + internal static TestAllExtensions GetAllExtensionsSet() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + SetAllExtensions(builder); + return builder.Build(); + } + + /// <summary> + /// Sets every field of the specified builder to the values expected by + /// AssertAllExtensionsSet. + /// </summary> + internal static void SetAllExtensions(TestAllExtensions.Builder message) { + message.SetExtension(UnitTestProtoFile.OptionalInt32Extension, 101); + message.SetExtension(UnitTestProtoFile.OptionalInt64Extension, 102L); + message.SetExtension(UnitTestProtoFile.OptionalUint32Extension, 103U); + message.SetExtension(UnitTestProtoFile.OptionalUint64Extension, 104UL); + message.SetExtension(UnitTestProtoFile.OptionalSint32Extension, 105); + message.SetExtension(UnitTestProtoFile.OptionalSint64Extension, 106L); + message.SetExtension(UnitTestProtoFile.OptionalFixed32Extension, 107U); + message.SetExtension(UnitTestProtoFile.OptionalFixed64Extension, 108UL); + message.SetExtension(UnitTestProtoFile.OptionalSfixed32Extension, 109); + message.SetExtension(UnitTestProtoFile.OptionalSfixed64Extension, 110L); + message.SetExtension(UnitTestProtoFile.OptionalFloatExtension, 111F); + message.SetExtension(UnitTestProtoFile.OptionalDoubleExtension, 112D); + message.SetExtension(UnitTestProtoFile.OptionalBoolExtension, true); + message.SetExtension(UnitTestProtoFile.OptionalStringExtension, "115"); + message.SetExtension(UnitTestProtoFile.OptionalBytesExtension, ToBytes("116")); + + message.SetExtension(UnitTestProtoFile.OptionalGroupExtension, OptionalGroup_extension.CreateBuilder().SetA(117).Build()); + message.SetExtension(UnitTestProtoFile.OptionalNestedMessageExtension, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(118).Build()); + message.SetExtension(UnitTestProtoFile.OptionalForeignMessageExtension, ForeignMessage.CreateBuilder().SetC(119).Build()); + message.SetExtension(UnitTestProtoFile.OptionalImportMessageExtension, ImportMessage.CreateBuilder().SetD(120).Build()); + + message.SetExtension(UnitTestProtoFile.OptionalNestedEnumExtension, TestAllTypes.Types.NestedEnum.BAZ); + message.SetExtension(UnitTestProtoFile.OptionalForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); + message.SetExtension(UnitTestProtoFile.OptionalImportEnumExtension, ImportEnum.IMPORT_BAZ); + + message.SetExtension(UnitTestProtoFile.OptionalStringPieceExtension, "124"); + message.SetExtension(UnitTestProtoFile.OptionalCordExtension, "125"); + + // ----------------------------------------------------------------- + + message.AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 201); + message.AddExtension(UnitTestProtoFile.RepeatedInt64Extension, 202L); + message.AddExtension(UnitTestProtoFile.RepeatedUint32Extension, 203U); + message.AddExtension(UnitTestProtoFile.RepeatedUint64Extension, 204UL); + message.AddExtension(UnitTestProtoFile.RepeatedSint32Extension, 205); + message.AddExtension(UnitTestProtoFile.RepeatedSint64Extension, 206L); + message.AddExtension(UnitTestProtoFile.RepeatedFixed32Extension, 207U); + message.AddExtension(UnitTestProtoFile.RepeatedFixed64Extension, 208UL); + message.AddExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 209); + message.AddExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 210L); + message.AddExtension(UnitTestProtoFile.RepeatedFloatExtension, 211F); + message.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 212D); + message.AddExtension(UnitTestProtoFile.RepeatedBoolExtension, true); + message.AddExtension(UnitTestProtoFile.RepeatedStringExtension, "215"); + message.AddExtension(UnitTestProtoFile.RepeatedBytesExtension, ToBytes("216")); + + message.AddExtension(UnitTestProtoFile.RepeatedGroupExtension, RepeatedGroup_extension.CreateBuilder().SetA(217).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(218).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, ForeignMessage.CreateBuilder().SetC(219).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedImportMessageExtension, ImportMessage.CreateBuilder().SetD(220).Build()); + + message.AddExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, TestAllTypes.Types.NestedEnum.BAR); + message.AddExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAR); + message.AddExtension(UnitTestProtoFile.RepeatedImportEnumExtension, ImportEnum.IMPORT_BAR); + + message.AddExtension(UnitTestProtoFile.RepeatedStringPieceExtension, "224"); + message.AddExtension(UnitTestProtoFile.RepeatedCordExtension, "225"); + + // Add a second one of each field. + message.AddExtension(UnitTestProtoFile.RepeatedInt32Extension, 301); + message.AddExtension(UnitTestProtoFile.RepeatedInt64Extension, 302L); + message.AddExtension(UnitTestProtoFile.RepeatedUint32Extension, 303U); + message.AddExtension(UnitTestProtoFile.RepeatedUint64Extension, 304UL); + message.AddExtension(UnitTestProtoFile.RepeatedSint32Extension, 305); + message.AddExtension(UnitTestProtoFile.RepeatedSint64Extension, 306L); + message.AddExtension(UnitTestProtoFile.RepeatedFixed32Extension, 307U); + message.AddExtension(UnitTestProtoFile.RepeatedFixed64Extension, 308UL); + message.AddExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 309); + message.AddExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 310L); + message.AddExtension(UnitTestProtoFile.RepeatedFloatExtension, 311F); + message.AddExtension(UnitTestProtoFile.RepeatedDoubleExtension, 312D); + message.AddExtension(UnitTestProtoFile.RepeatedBoolExtension, false); + message.AddExtension(UnitTestProtoFile.RepeatedStringExtension, "315"); + message.AddExtension(UnitTestProtoFile.RepeatedBytesExtension, ToBytes("316")); + + message.AddExtension(UnitTestProtoFile.RepeatedGroupExtension, RepeatedGroup_extension.CreateBuilder().SetA(317).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(318).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, ForeignMessage.CreateBuilder().SetC(319).Build()); + message.AddExtension(UnitTestProtoFile.RepeatedImportMessageExtension, ImportMessage.CreateBuilder().SetD(320).Build()); + + message.AddExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, TestAllTypes.Types.NestedEnum.BAZ); + message.AddExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, ForeignEnum.FOREIGN_BAZ); + message.AddExtension(UnitTestProtoFile.RepeatedImportEnumExtension, ImportEnum.IMPORT_BAZ); + + message.AddExtension(UnitTestProtoFile.RepeatedStringPieceExtension, "324"); + message.AddExtension(UnitTestProtoFile.RepeatedCordExtension, "325"); + + // ----------------------------------------------------------------- + + message.SetExtension(UnitTestProtoFile.DefaultInt32Extension, 401); + message.SetExtension(UnitTestProtoFile.DefaultInt64Extension, 402L); + message.SetExtension(UnitTestProtoFile.DefaultUint32Extension, 403U); + message.SetExtension(UnitTestProtoFile.DefaultUint64Extension, 404UL); + message.SetExtension(UnitTestProtoFile.DefaultSint32Extension, 405); + message.SetExtension(UnitTestProtoFile.DefaultSint64Extension, 406L); + message.SetExtension(UnitTestProtoFile.DefaultFixed32Extension, 407U); + message.SetExtension(UnitTestProtoFile.DefaultFixed64Extension, 408UL); + message.SetExtension(UnitTestProtoFile.DefaultSfixed32Extension, 409); + message.SetExtension(UnitTestProtoFile.DefaultSfixed64Extension, 410L); + message.SetExtension(UnitTestProtoFile.DefaultFloatExtension, 411F); + message.SetExtension(UnitTestProtoFile.DefaultDoubleExtension, 412D); + message.SetExtension(UnitTestProtoFile.DefaultBoolExtension, false); + message.SetExtension(UnitTestProtoFile.DefaultStringExtension, "415"); + message.SetExtension(UnitTestProtoFile.DefaultBytesExtension, ToBytes("416")); + + message.SetExtension(UnitTestProtoFile.DefaultNestedEnumExtension, TestAllTypes.Types.NestedEnum.FOO); + message.SetExtension(UnitTestProtoFile.DefaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO); + message.SetExtension(UnitTestProtoFile.DefaultImportEnumExtension, ImportEnum.IMPORT_FOO); + + message.SetExtension(UnitTestProtoFile.DefaultStringPieceExtension, "424"); + message.SetExtension(UnitTestProtoFile.DefaultCordExtension, "425"); + } + + internal static void ModifyRepeatedFields(TestAllTypes.Builder message) { + message.SetRepeatedInt32(1, 501); + message.SetRepeatedInt64(1, 502); + message.SetRepeatedUint32(1, 503); + message.SetRepeatedUint64(1, 504); + message.SetRepeatedSint32(1, 505); + message.SetRepeatedSint64(1, 506); + message.SetRepeatedFixed32(1, 507); + message.SetRepeatedFixed64(1, 508); + message.SetRepeatedSfixed32(1, 509); + message.SetRepeatedSfixed64(1, 510); + message.SetRepeatedFloat(1, 511); + message.SetRepeatedDouble(1, 512); + message.SetRepeatedBool(1, true); + message.SetRepeatedString(1, "515"); + message.SetRepeatedBytes(1, ToBytes("516")); + + message.SetRepeatedGroup(1, TestAllTypes.Types.RepeatedGroup.CreateBuilder().SetA(517).Build()); + message.SetRepeatedNestedMessage(1, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(518).Build()); + message.SetRepeatedForeignMessage(1, ForeignMessage.CreateBuilder().SetC(519).Build()); + message.SetRepeatedImportMessage(1, ImportMessage.CreateBuilder().SetD(520).Build()); + + message.SetRepeatedNestedEnum(1, TestAllTypes.Types.NestedEnum.FOO); + message.SetRepeatedForeignEnum(1, ForeignEnum.FOREIGN_FOO); + message.SetRepeatedImportEnum(1, ImportEnum.IMPORT_FOO); + + message.SetRepeatedStringPiece(1, "524"); + message.SetRepeatedCord(1, "525"); + } + + internal static void AssertRepeatedFieldsModified(TestAllTypes message) { + // ModifyRepeatedFields only sets the second repeated element of each + // field. In addition to verifying this, we also verify that the first + // element and size were *not* modified. + Assert.AreEqual(2, message.RepeatedInt32Count); + Assert.AreEqual(2, message.RepeatedInt64Count); + Assert.AreEqual(2, message.RepeatedUint32Count); + Assert.AreEqual(2, message.RepeatedUint64Count); + Assert.AreEqual(2, message.RepeatedSint32Count); + Assert.AreEqual(2, message.RepeatedSint64Count); + Assert.AreEqual(2, message.RepeatedFixed32Count); + Assert.AreEqual(2, message.RepeatedFixed64Count); + Assert.AreEqual(2, message.RepeatedSfixed32Count); + Assert.AreEqual(2, message.RepeatedSfixed64Count); + Assert.AreEqual(2, message.RepeatedFloatCount); + Assert.AreEqual(2, message.RepeatedDoubleCount); + Assert.AreEqual(2, message.RepeatedBoolCount); + Assert.AreEqual(2, message.RepeatedStringCount); + Assert.AreEqual(2, message.RepeatedBytesCount); + + Assert.AreEqual(2, message.RepeatedGroupCount); + Assert.AreEqual(2, message.RepeatedNestedMessageCount); + Assert.AreEqual(2, message.RepeatedForeignMessageCount); + Assert.AreEqual(2, message.RepeatedImportMessageCount); + Assert.AreEqual(2, message.RepeatedNestedEnumCount); + Assert.AreEqual(2, message.RepeatedForeignEnumCount); + Assert.AreEqual(2, message.RepeatedImportEnumCount); + + Assert.AreEqual(2, message.RepeatedStringPieceCount); + Assert.AreEqual(2, message.RepeatedCordCount); + + Assert.AreEqual(201, message.GetRepeatedInt32(0)); + Assert.AreEqual(202L, message.GetRepeatedInt64(0)); + Assert.AreEqual(203U, message.GetRepeatedUint32(0)); + Assert.AreEqual(204UL, message.GetRepeatedUint64(0)); + Assert.AreEqual(205, message.GetRepeatedSint32(0)); + Assert.AreEqual(206L, message.GetRepeatedSint64(0)); + Assert.AreEqual(207U, message.GetRepeatedFixed32(0)); + Assert.AreEqual(208UL, message.GetRepeatedFixed64(0)); + Assert.AreEqual(209, message.GetRepeatedSfixed32(0)); + Assert.AreEqual(210L, message.GetRepeatedSfixed64(0)); + Assert.AreEqual(211F, message.GetRepeatedFloat(0)); + Assert.AreEqual(212D, message.GetRepeatedDouble(0)); + Assert.AreEqual(true, message.GetRepeatedBool(0)); + Assert.AreEqual("215", message.GetRepeatedString(0)); + Assert.AreEqual(ToBytes("216"), message.GetRepeatedBytes(0)); + + Assert.AreEqual(217, message.GetRepeatedGroup(0).A); + Assert.AreEqual(218, message.GetRepeatedNestedMessage(0).Bb); + Assert.AreEqual(219, message.GetRepeatedForeignMessage(0).C); + Assert.AreEqual(220, message.GetRepeatedImportMessage(0).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetRepeatedNestedEnum(0)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetRepeatedForeignEnum(0)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetRepeatedImportEnum(0)); + + Assert.AreEqual("224", message.GetRepeatedStringPiece(0)); + Assert.AreEqual("225", message.GetRepeatedCord(0)); + + // Actually verify the second (modified) elements now. + Assert.AreEqual(501, message.GetRepeatedInt32(1)); + Assert.AreEqual(502L, message.GetRepeatedInt64(1)); + Assert.AreEqual(503U, message.GetRepeatedUint32(1)); + Assert.AreEqual(504UL, message.GetRepeatedUint64(1)); + Assert.AreEqual(505, message.GetRepeatedSint32(1)); + Assert.AreEqual(506L, message.GetRepeatedSint64(1)); + Assert.AreEqual(507U, message.GetRepeatedFixed32(1)); + Assert.AreEqual(508UL, message.GetRepeatedFixed64(1)); + Assert.AreEqual(509, message.GetRepeatedSfixed32(1)); + Assert.AreEqual(510L, message.GetRepeatedSfixed64(1)); + Assert.AreEqual(511F, message.GetRepeatedFloat(1)); + Assert.AreEqual(512D, message.GetRepeatedDouble(1)); + Assert.AreEqual(true, message.GetRepeatedBool(1)); + Assert.AreEqual("515", message.GetRepeatedString(1)); + Assert.AreEqual(ToBytes("516"), message.GetRepeatedBytes(1)); + + Assert.AreEqual(517, message.GetRepeatedGroup(1).A); + Assert.AreEqual(518, message.GetRepeatedNestedMessage(1).Bb); + Assert.AreEqual(519, message.GetRepeatedForeignMessage(1).C); + Assert.AreEqual(520, message.GetRepeatedImportMessage(1).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetRepeatedNestedEnum(1)); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetRepeatedForeignEnum(1)); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetRepeatedImportEnum(1)); + + Assert.AreEqual("524", message.GetRepeatedStringPiece(1)); + Assert.AreEqual("525", message.GetRepeatedCord(1)); + } + + /// <summary> + /// Helper to assert that sequences are equal. + /// </summary> + internal static void AssertEqual<T>(IEnumerable<T> first, IEnumerable<T> second) { + using (IEnumerator<T> firstEnumerator = first.GetEnumerator()) { + foreach (T secondElement in second) { + Assert.IsTrue(firstEnumerator.MoveNext(), "First enumerator ran out of elements too early."); + Assert.AreEqual(firstEnumerator.Current, secondElement); + } + Assert.IsFalse(firstEnumerator.MoveNext(), "Second enumerator ran out of elements too early."); + } + } + + internal static void AssertEqualBytes(byte[] expected, byte[] actual) { + Assert.AreEqual(ByteString.CopyFrom(expected), ByteString.CopyFrom(actual)); + } + + internal static void AssertAllExtensionsSet(TestAllExtensions message) { + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalInt32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalInt64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalUint32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalUint64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSint32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSint64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalFixed32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalFixed64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSfixed32Extension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalSfixed64Extension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalFloatExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalDoubleExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalBoolExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalStringExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalBytesExtension )); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalGroupExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalNestedMessageExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalForeignMessageExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalImportMessageExtension )); + + Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalGroupExtension ).HasA); + Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension ).HasBb); + Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).HasC); + Assert.IsTrue(message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension ).HasD); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalNestedEnumExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalImportEnumExtension )); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalStringPieceExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.OptionalCordExtension)); + + Assert.AreEqual(101 , message.GetExtension(UnitTestProtoFile.OptionalInt32Extension )); + Assert.AreEqual(102L , message.GetExtension(UnitTestProtoFile.OptionalInt64Extension )); + Assert.AreEqual(103U , message.GetExtension(UnitTestProtoFile.OptionalUint32Extension )); + Assert.AreEqual(104UL , message.GetExtension(UnitTestProtoFile.OptionalUint64Extension )); + Assert.AreEqual(105 , message.GetExtension(UnitTestProtoFile.OptionalSint32Extension )); + Assert.AreEqual(106L , message.GetExtension(UnitTestProtoFile.OptionalSint64Extension )); + Assert.AreEqual(107U , message.GetExtension(UnitTestProtoFile.OptionalFixed32Extension )); + Assert.AreEqual(108UL , message.GetExtension(UnitTestProtoFile.OptionalFixed64Extension )); + Assert.AreEqual(109 , message.GetExtension(UnitTestProtoFile.OptionalSfixed32Extension)); + Assert.AreEqual(110L , message.GetExtension(UnitTestProtoFile.OptionalSfixed64Extension)); + Assert.AreEqual(111F , message.GetExtension(UnitTestProtoFile.OptionalFloatExtension )); + Assert.AreEqual(112D , message.GetExtension(UnitTestProtoFile.OptionalDoubleExtension )); + Assert.AreEqual(true , message.GetExtension(UnitTestProtoFile.OptionalBoolExtension )); + Assert.AreEqual("115", message.GetExtension(UnitTestProtoFile.OptionalStringExtension )); + Assert.AreEqual(ToBytes("116"), message.GetExtension(UnitTestProtoFile.OptionalBytesExtension)); + + Assert.AreEqual(117, message.GetExtension(UnitTestProtoFile.OptionalGroupExtension ).A); + Assert.AreEqual(118, message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension ).Bb); + Assert.AreEqual(119, message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).C); + Assert.AreEqual(120, message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension ).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); + Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetExtension(UnitTestProtoFile.OptionalImportEnumExtension)); + + Assert.AreEqual("124", message.GetExtension(UnitTestProtoFile.OptionalStringPieceExtension)); + Assert.AreEqual("125", message.GetExtension(UnitTestProtoFile.OptionalCordExtension)); + + // ----------------------------------------------------------------- + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt64Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint32Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint64Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint32Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint64Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed32Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed64Extension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFloatExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBoolExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBytesExtension )); + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedGroupExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedMessageExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignMessageExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportMessageExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedEnumExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignEnumExtension )); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportEnumExtension )); + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringPieceExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedCordExtension)); + + Assert.AreEqual(201 , message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension , 0)); + Assert.AreEqual(202L , message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension , 0)); + Assert.AreEqual(203U , message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension , 0)); + Assert.AreEqual(204UL , message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension , 0)); + Assert.AreEqual(205 , message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension , 0)); + Assert.AreEqual(206L , message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension , 0)); + Assert.AreEqual(207U , message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension , 0)); + Assert.AreEqual(208UL , message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension , 0)); + Assert.AreEqual(209 , message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 0)); + Assert.AreEqual(210L , message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 0)); + Assert.AreEqual(211F , message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension , 0)); + Assert.AreEqual(212D , message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension , 0)); + Assert.AreEqual(true , message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension , 0)); + Assert.AreEqual("215", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension , 0)); + Assert.AreEqual(ToBytes("216"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 0)); + + Assert.AreEqual(217, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension , 0).A); + Assert.AreEqual(218, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension , 0).Bb); + Assert.AreEqual(219, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 0).C); + Assert.AreEqual(220, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension , 0).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 0)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 0)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 0)); + + Assert.AreEqual("224", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 0)); + Assert.AreEqual("225", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 0)); + + Assert.AreEqual(301 , message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension , 1)); + Assert.AreEqual(302L , message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension , 1)); + Assert.AreEqual(303U , message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension , 1)); + Assert.AreEqual(304UL , message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension , 1)); + Assert.AreEqual(305 , message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension , 1)); + Assert.AreEqual(306L , message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension , 1)); + Assert.AreEqual(307U , message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension , 1)); + Assert.AreEqual(308UL , message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension , 1)); + Assert.AreEqual(309 , message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 1)); + Assert.AreEqual(310L , message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 1)); + Assert.AreEqual(311F , message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension , 1)); + Assert.AreEqual(312D , message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension , 1)); + Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension , 1)); + Assert.AreEqual("315", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension , 1)); + Assert.AreEqual(ToBytes("316"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 1)); + + Assert.AreEqual(317, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension , 1).A); + Assert.AreEqual(318, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension , 1).Bb); + Assert.AreEqual(319, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 1).C); + Assert.AreEqual(320, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension , 1).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAZ, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 1)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAZ, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 1)); + Assert.AreEqual(ImportEnum.IMPORT_BAZ, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 1)); + + Assert.AreEqual("324", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 1)); + Assert.AreEqual("325", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 1)); + + // ----------------------------------------------------------------- + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultInt32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultInt64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultUint32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultUint64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSint32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSint64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultFixed32Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultFixed64Extension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSfixed32Extension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultSfixed64Extension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultFloatExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultDoubleExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultBoolExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultStringExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultBytesExtension )); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultNestedEnumExtension )); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultImportEnumExtension )); + + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultStringPieceExtension)); + Assert.IsTrue(message.HasExtension(UnitTestProtoFile.DefaultCordExtension)); + + Assert.AreEqual(401 , message.GetExtension(UnitTestProtoFile.DefaultInt32Extension )); + Assert.AreEqual(402L , message.GetExtension(UnitTestProtoFile.DefaultInt64Extension )); + Assert.AreEqual(403U , message.GetExtension(UnitTestProtoFile.DefaultUint32Extension )); + Assert.AreEqual(404UL , message.GetExtension(UnitTestProtoFile.DefaultUint64Extension )); + Assert.AreEqual(405 , message.GetExtension(UnitTestProtoFile.DefaultSint32Extension )); + Assert.AreEqual(406L , message.GetExtension(UnitTestProtoFile.DefaultSint64Extension )); + Assert.AreEqual(407U , message.GetExtension(UnitTestProtoFile.DefaultFixed32Extension )); + Assert.AreEqual(408UL , message.GetExtension(UnitTestProtoFile.DefaultFixed64Extension )); + Assert.AreEqual(409 , message.GetExtension(UnitTestProtoFile.DefaultSfixed32Extension)); + Assert.AreEqual(410L , message.GetExtension(UnitTestProtoFile.DefaultSfixed64Extension)); + Assert.AreEqual(411F , message.GetExtension(UnitTestProtoFile.DefaultFloatExtension )); + Assert.AreEqual(412D , message.GetExtension(UnitTestProtoFile.DefaultDoubleExtension )); + Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.DefaultBoolExtension )); + Assert.AreEqual("415", message.GetExtension(UnitTestProtoFile.DefaultStringExtension )); + Assert.AreEqual(ToBytes("416"), message.GetExtension(UnitTestProtoFile.DefaultBytesExtension)); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(UnitTestProtoFile.DefaultNestedEnumExtension )); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(UnitTestProtoFile.DefaultImportEnumExtension)); + + Assert.AreEqual("424", message.GetExtension(UnitTestProtoFile.DefaultStringPieceExtension)); + Assert.AreEqual("425", message.GetExtension(UnitTestProtoFile.DefaultCordExtension)); + } + + /// <summary> + /// Modifies the repeated extensions of the given message to contain the values + /// expected by AssertRepeatedExtensionsModified. + /// </summary> + internal static void ModifyRepeatedExtensions(TestAllExtensions.Builder message) { + message.SetExtension(UnitTestProtoFile.RepeatedInt32Extension, 1, 501); + message.SetExtension(UnitTestProtoFile.RepeatedInt64Extension, 1, 502L); + message.SetExtension(UnitTestProtoFile.RepeatedUint32Extension, 1, 503U); + message.SetExtension(UnitTestProtoFile.RepeatedUint64Extension, 1, 504UL); + message.SetExtension(UnitTestProtoFile.RepeatedSint32Extension, 1, 505); + message.SetExtension(UnitTestProtoFile.RepeatedSint64Extension, 1, 506L); + message.SetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 1, 507U); + message.SetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 1, 508UL); + message.SetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 1, 509); + message.SetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 1, 510L); + message.SetExtension(UnitTestProtoFile.RepeatedFloatExtension, 1, 511F); + message.SetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1, 512D); + message.SetExtension(UnitTestProtoFile.RepeatedBoolExtension, 1, true); + message.SetExtension(UnitTestProtoFile.RepeatedStringExtension, 1, "515"); + message.SetExtension(UnitTestProtoFile.RepeatedBytesExtension, 1, ToBytes("516")); + + message.SetExtension(UnitTestProtoFile.RepeatedGroupExtension, 1, RepeatedGroup_extension.CreateBuilder().SetA(517).Build()); + message.SetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, 1, TestAllTypes.Types.NestedMessage.CreateBuilder().SetBb(518).Build()); + message.SetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 1, ForeignMessage.CreateBuilder().SetC(519).Build()); + message.SetExtension(UnitTestProtoFile.RepeatedImportMessageExtension, 1, ImportMessage.CreateBuilder().SetD(520).Build()); + + message.SetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 1, TestAllTypes.Types.NestedEnum.FOO); + message.SetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 1, ForeignEnum.FOREIGN_FOO); + message.SetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 1, ImportEnum.IMPORT_FOO); + + message.SetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 1, "524"); + message.SetExtension(UnitTestProtoFile.RepeatedCordExtension, 1, "525"); + } + + /// <summary> + /// Asserts that all repeated extensions are set to the values assigned by + /// SetAllExtensions follwed by ModifyRepeatedExtensions. + /// </summary> + internal static void AssertRepeatedExtensionsModified(TestAllExtensions message) { + // ModifyRepeatedFields only sets the second repeated element of each + // field. In addition to verifying this, we also verify that the first + // element and size were *not* modified. + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed32Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed64Extension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedFloatExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBoolExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedBytesExtension)); + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedGroupExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedMessageExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignMessageExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportMessageExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedEnumExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignEnumExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportEnumExtension)); + + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringPieceExtension)); + Assert.AreEqual(2, message.GetExtensionCount(UnitTestProtoFile.RepeatedCordExtension)); + + Assert.AreEqual(201, message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension, 0)); + Assert.AreEqual(202L, message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension, 0)); + Assert.AreEqual(203U, message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension, 0)); + Assert.AreEqual(204UL, message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension, 0)); + Assert.AreEqual(205, message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension, 0)); + Assert.AreEqual(206L, message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension, 0)); + Assert.AreEqual(207U, message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 0)); + Assert.AreEqual(208UL, message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 0)); + Assert.AreEqual(209, message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 0)); + Assert.AreEqual(210L, message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 0)); + Assert.AreEqual(211F, message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension, 0)); + Assert.AreEqual(212D, message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 0)); + Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension, 0)); + Assert.AreEqual("215", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension, 0)); + Assert.AreEqual(ToBytes("216"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 0)); + + Assert.AreEqual(217, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension, 0).A); + Assert.AreEqual(218, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, 0).Bb); + Assert.AreEqual(219, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 0).C); + Assert.AreEqual(220, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension, 0).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 0)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 0)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 0)); + + Assert.AreEqual("224", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 0)); + Assert.AreEqual("225", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 0)); + + // Actually verify the second (modified) elements now. + Assert.AreEqual(501, message.GetExtension(UnitTestProtoFile.RepeatedInt32Extension, 1)); + Assert.AreEqual(502L, message.GetExtension(UnitTestProtoFile.RepeatedInt64Extension, 1)); + Assert.AreEqual(503U, message.GetExtension(UnitTestProtoFile.RepeatedUint32Extension, 1)); + Assert.AreEqual(504UL, message.GetExtension(UnitTestProtoFile.RepeatedUint64Extension, 1)); + Assert.AreEqual(505, message.GetExtension(UnitTestProtoFile.RepeatedSint32Extension, 1)); + Assert.AreEqual(506L, message.GetExtension(UnitTestProtoFile.RepeatedSint64Extension, 1)); + Assert.AreEqual(507U, message.GetExtension(UnitTestProtoFile.RepeatedFixed32Extension, 1)); + Assert.AreEqual(508UL, message.GetExtension(UnitTestProtoFile.RepeatedFixed64Extension, 1)); + Assert.AreEqual(509, message.GetExtension(UnitTestProtoFile.RepeatedSfixed32Extension, 1)); + Assert.AreEqual(510L, message.GetExtension(UnitTestProtoFile.RepeatedSfixed64Extension, 1)); + Assert.AreEqual(511F, message.GetExtension(UnitTestProtoFile.RepeatedFloatExtension, 1)); + Assert.AreEqual(512D, message.GetExtension(UnitTestProtoFile.RepeatedDoubleExtension, 1)); + Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.RepeatedBoolExtension, 1)); + Assert.AreEqual("515", message.GetExtension(UnitTestProtoFile.RepeatedStringExtension, 1)); + Assert.AreEqual(ToBytes("516"), message.GetExtension(UnitTestProtoFile.RepeatedBytesExtension, 1)); + + Assert.AreEqual(517, message.GetExtension(UnitTestProtoFile.RepeatedGroupExtension, 1).A); + Assert.AreEqual(518, message.GetExtension(UnitTestProtoFile.RepeatedNestedMessageExtension, 1).Bb); + Assert.AreEqual(519, message.GetExtension(UnitTestProtoFile.RepeatedForeignMessageExtension, 1).C); + Assert.AreEqual(520, message.GetExtension(UnitTestProtoFile.RepeatedImportMessageExtension, 1).D); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension, 1)); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(UnitTestProtoFile.RepeatedForeignEnumExtension, 1)); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(UnitTestProtoFile.RepeatedImportEnumExtension, 1)); + + Assert.AreEqual("524", message.GetExtension(UnitTestProtoFile.RepeatedStringPieceExtension, 1)); + Assert.AreEqual("525", message.GetExtension(UnitTestProtoFile.RepeatedCordExtension, 1)); + } + + internal static void AssertExtensionsClear(TestAllExtensions message) { + // HasBlah() should initially be false for all optional fields. + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalInt32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalInt64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalUint32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalUint64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSint32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSint64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalFixed32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalFixed64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSfixed32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalSfixed64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalFloatExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalDoubleExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalBoolExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalStringExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalBytesExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalGroupExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalNestedMessageExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalForeignMessageExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalImportMessageExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalImportEnumExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalStringPieceExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.OptionalCordExtension)); + + // Optional fields without defaults are set to zero or something like it. + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalInt32Extension)); + Assert.AreEqual(0L, message.GetExtension(UnitTestProtoFile.OptionalInt64Extension)); + Assert.AreEqual(0U, message.GetExtension(UnitTestProtoFile.OptionalUint32Extension)); + Assert.AreEqual(0UL, message.GetExtension(UnitTestProtoFile.OptionalUint64Extension)); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalSint32Extension)); + Assert.AreEqual(0L, message.GetExtension(UnitTestProtoFile.OptionalSint64Extension)); + Assert.AreEqual(0U, message.GetExtension(UnitTestProtoFile.OptionalFixed32Extension)); + Assert.AreEqual(0UL, message.GetExtension(UnitTestProtoFile.OptionalFixed64Extension)); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalSfixed32Extension)); + Assert.AreEqual(0L, message.GetExtension(UnitTestProtoFile.OptionalSfixed64Extension)); + Assert.AreEqual(0F, message.GetExtension(UnitTestProtoFile.OptionalFloatExtension)); + Assert.AreEqual(0D, message.GetExtension(UnitTestProtoFile.OptionalDoubleExtension)); + Assert.AreEqual(false, message.GetExtension(UnitTestProtoFile.OptionalBoolExtension)); + Assert.AreEqual("", message.GetExtension(UnitTestProtoFile.OptionalStringExtension)); + Assert.AreEqual(ByteString.Empty, message.GetExtension(UnitTestProtoFile.OptionalBytesExtension)); + + // Embedded messages should also be clear. + Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalGroupExtension).HasA); + Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension).HasBb); + Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).HasC); + Assert.IsFalse(message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension).HasD); + + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalGroupExtension).A); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalNestedMessageExtension).Bb); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalForeignMessageExtension).C); + Assert.AreEqual(0, message.GetExtension(UnitTestProtoFile.OptionalImportMessageExtension).D); + + // Enums without defaults are set to the first value in the enum. + Assert.AreEqual(TestAllTypes.Types.NestedEnum.FOO, message.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); + Assert.AreEqual(ForeignEnum.FOREIGN_FOO, message.GetExtension(UnitTestProtoFile.OptionalForeignEnumExtension)); + Assert.AreEqual(ImportEnum.IMPORT_FOO, message.GetExtension(UnitTestProtoFile.OptionalImportEnumExtension)); + + Assert.AreEqual("", message.GetExtension(UnitTestProtoFile.OptionalStringPieceExtension)); + Assert.AreEqual("", message.GetExtension(UnitTestProtoFile.OptionalCordExtension)); + + // Repeated fields are empty. + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedInt64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedUint64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSint64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedFixed64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed32Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedSfixed64Extension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedFloatExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedDoubleExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedBoolExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedBytesExtension)); + + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedGroupExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedMessageExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignMessageExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportMessageExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedNestedEnumExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedForeignEnumExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedImportEnumExtension)); + + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedStringPieceExtension)); + Assert.AreEqual(0, message.GetExtensionCount(UnitTestProtoFile.RepeatedCordExtension)); + + // HasBlah() should also be false for all default fields. + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultInt32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultInt64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultUint32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultUint64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSint32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSint64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultFixed32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultFixed64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSfixed32Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultSfixed64Extension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultFloatExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultDoubleExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultBoolExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultStringExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultBytesExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultNestedEnumExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultImportEnumExtension)); + + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultStringPieceExtension)); + Assert.IsFalse(message.HasExtension(UnitTestProtoFile.DefaultCordExtension)); + + // Fields with defaults have their default values (duh). + Assert.AreEqual(41, message.GetExtension(UnitTestProtoFile.DefaultInt32Extension)); + Assert.AreEqual(42L, message.GetExtension(UnitTestProtoFile.DefaultInt64Extension)); + Assert.AreEqual(43U, message.GetExtension(UnitTestProtoFile.DefaultUint32Extension)); + Assert.AreEqual(44UL, message.GetExtension(UnitTestProtoFile.DefaultUint64Extension)); + Assert.AreEqual(-45, message.GetExtension(UnitTestProtoFile.DefaultSint32Extension)); + Assert.AreEqual(46L, message.GetExtension(UnitTestProtoFile.DefaultSint64Extension)); + Assert.AreEqual(47U, message.GetExtension(UnitTestProtoFile.DefaultFixed32Extension)); + Assert.AreEqual(48UL, message.GetExtension(UnitTestProtoFile.DefaultFixed64Extension)); + Assert.AreEqual(49, message.GetExtension(UnitTestProtoFile.DefaultSfixed32Extension)); + Assert.AreEqual(-50L, message.GetExtension(UnitTestProtoFile.DefaultSfixed64Extension)); + Assert.AreEqual(51.5F, message.GetExtension(UnitTestProtoFile.DefaultFloatExtension)); + Assert.AreEqual(52e3D, message.GetExtension(UnitTestProtoFile.DefaultDoubleExtension)); + Assert.AreEqual(true, message.GetExtension(UnitTestProtoFile.DefaultBoolExtension)); + Assert.AreEqual("hello", message.GetExtension(UnitTestProtoFile.DefaultStringExtension)); + Assert.AreEqual(ToBytes("world"), message.GetExtension(UnitTestProtoFile.DefaultBytesExtension)); + + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, message.GetExtension(UnitTestProtoFile.DefaultNestedEnumExtension)); + Assert.AreEqual(ForeignEnum.FOREIGN_BAR, message.GetExtension(UnitTestProtoFile.DefaultForeignEnumExtension)); + Assert.AreEqual(ImportEnum.IMPORT_BAR, message.GetExtension(UnitTestProtoFile.DefaultImportEnumExtension)); + + Assert.AreEqual("abc", message.GetExtension(UnitTestProtoFile.DefaultStringPieceExtension)); + Assert.AreEqual("123", message.GetExtension(UnitTestProtoFile.DefaultCordExtension)); + } + + /// <summary> + /// Helper to construct a byte array from a bunch of bytes. + /// </summary> + internal static byte[] Bytes(params byte[] bytesAsInts) { + byte[] bytes = new byte[bytesAsInts.Length]; + for (int i = 0; i < bytesAsInts.Length; i++) { + bytes[i] = (byte)bytesAsInts[i]; + } + return bytes; + } + } +} diff --git a/src/ProtocolBuffers.Test/TextFormatTest.cs b/src/ProtocolBuffers.Test/TextFormatTest.cs new file mode 100644 index 00000000..8d30b96c --- /dev/null +++ b/src/ProtocolBuffers.Test/TextFormatTest.cs @@ -0,0 +1,487 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.IO; +using System.Text; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class TextFormatTest { + + private static readonly string AllFieldsSetText = TestUtil.ReadTextFromFile("text_format_unittest_data.txt"); + private static readonly string AllExtensionsSetText = TestUtil.ReadTextFromFile("text_format_unittest_extensions_data.txt"); + + /// <summary> + /// Note that this is slightly different to the Java - 123.0 becomes 123, and 1.23E17 becomes 1.23E+17. + /// Both of these differences can be parsed by the Java and the C++, and we can parse their output too. + /// </summary> + private const string ExoticText = + "repeated_int32: -1\n" + + "repeated_int32: -2147483648\n" + + "repeated_int64: -1\n" + + "repeated_int64: -9223372036854775808\n" + + "repeated_uint32: 4294967295\n" + + "repeated_uint32: 2147483648\n" + + "repeated_uint64: 18446744073709551615\n" + + "repeated_uint64: 9223372036854775808\n" + + "repeated_double: 123\n" + + "repeated_double: 123.5\n" + + "repeated_double: 0.125\n" + + "repeated_double: 1.23E+17\n" + + "repeated_double: 1.235E+22\n" + + "repeated_double: 1.235E-18\n" + + "repeated_double: 123.456789\n" + + "repeated_double: Infinity\n" + + "repeated_double: -Infinity\n" + + "repeated_double: NaN\n" + + "repeated_string: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"" + + "\\341\\210\\264\"\n" + + "repeated_bytes: \"\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"\\376\"\n"; + + private const string MessageSetText = + "[protobuf_unittest.TestMessageSetExtension1] {\n" + + " i: 123\n" + + "}\n" + + "[protobuf_unittest.TestMessageSetExtension2] {\n" + + " str: \"foo\"\n" + + "}\n"; + + /// <summary> + /// Print TestAllTypes and compare with golden file. + /// </summary> + [Test] + public void PrintMessage() { + string text = TextFormat.PrintToString(TestUtil.GetAllSet()); + Assert.AreEqual(AllFieldsSetText.Replace("\r\n", "\n"), text.Replace("\r\n", "\n")); + } + + /// <summary> + /// Print TestAllExtensions and compare with golden file. + /// </summary> + [Test] + public void PrintExtensions() { + string text = TextFormat.PrintToString(TestUtil.GetAllExtensionsSet()); + + Assert.AreEqual(AllExtensionsSetText.Replace("\r\n", "\n"), text.Replace("\r\n", "\n")); + } + + /// <summary> + /// Test printing of unknown fields in a message. + /// </summary> + [Test] + public void PrintUnknownFields() { + TestEmptyMessage message = + TestEmptyMessage.CreateBuilder() + .SetUnknownFields( + UnknownFieldSet.CreateBuilder() + .AddField(5, + UnknownField.CreateBuilder() + .AddVarint(1) + .AddFixed32(2) + .AddFixed64(3) + .AddLengthDelimited(ByteString.CopyFromUtf8("4")) + .AddGroup( + UnknownFieldSet.CreateBuilder() + .AddField(10, + UnknownField.CreateBuilder() + .AddVarint(5) + .Build()) + .Build()) + .Build()) + .AddField(8, + UnknownField.CreateBuilder() + .AddVarint(1) + .AddVarint(2) + .AddVarint(3) + .Build()) + .AddField(15, + UnknownField.CreateBuilder() + .AddVarint(0xABCDEF1234567890L) + .AddFixed32(0xABCD1234) + .AddFixed64(0xABCDEF1234567890L) + .Build()) + .Build()) + .Build(); + + Assert.AreEqual( + "5: 1\n" + + "5: 0x00000002\n" + + "5: 0x0000000000000003\n" + + "5: \"4\"\n" + + "5 {\n" + + " 10: 5\n" + + "}\n" + + "8: 1\n" + + "8: 2\n" + + "8: 3\n" + + "15: 12379813812177893520\n" + + "15: 0xabcd1234\n" + + "15: 0xabcdef1234567890\n", + TextFormat.PrintToString(message)); + } + + /// <summary> + /// Helper to construct a ByteString from a string containing only 8-bit + /// characters. The characters are converted directly to bytes, *not* + /// encoded using UTF-8. + /// </summary> + private static ByteString Bytes(string str) { + return ByteString.CopyFrom(Encoding.GetEncoding(28591).GetBytes(str)); + } + + [Test] + public void PrintExotic() { + IMessage message = TestAllTypes.CreateBuilder() + // Signed vs. unsigned numbers. + .AddRepeatedInt32 (-1) + .AddRepeatedUint32(uint.MaxValue) + .AddRepeatedInt64 (-1) + .AddRepeatedUint64(ulong.MaxValue) + + .AddRepeatedInt32 (1 << 31) + .AddRepeatedUint32(1U << 31) + .AddRepeatedInt64 (1L << 63) + .AddRepeatedUint64(1UL << 63) + + // Floats of various precisions and exponents. + .AddRepeatedDouble(123) + .AddRepeatedDouble(123.5) + .AddRepeatedDouble(0.125) + .AddRepeatedDouble(123e15) + .AddRepeatedDouble(123.5e20) + .AddRepeatedDouble(123.5e-20) + .AddRepeatedDouble(123.456789) + .AddRepeatedDouble(Double.PositiveInfinity) + .AddRepeatedDouble(Double.NegativeInfinity) + .AddRepeatedDouble(Double.NaN) + + // Strings and bytes that needing escaping. + .AddRepeatedString("\0\u0001\u0007\b\f\n\r\t\v\\\'\"\u1234") + .AddRepeatedBytes(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\"\u00fe")) + .Build(); + + Assert.AreEqual(ExoticText, message.ToString()); + } + + [Test] + public void PrintMessageSet() { + TestMessageSet messageSet = + TestMessageSet.CreateBuilder() + .SetExtension( + TestMessageSetExtension1.MessageSetExtension, + TestMessageSetExtension1.CreateBuilder().SetI(123).Build()) + .SetExtension( + TestMessageSetExtension2.MessageSetExtension, + TestMessageSetExtension2.CreateBuilder().SetStr("foo").Build()) + .Build(); + + Assert.AreEqual(MessageSetText, messageSet.ToString()); + } + + // ================================================================= + + [Test] + public void Parse() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge(AllFieldsSetText, builder); + TestUtil.AssertAllFieldsSet(builder.Build()); + } + + [Test] + public void ParseReader() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge(new StringReader(AllFieldsSetText), builder); + TestUtil.AssertAllFieldsSet(builder.Build()); + } + + [Test] + public void ParseExtensions() { + TestAllExtensions.Builder builder = TestAllExtensions.CreateBuilder(); + TextFormat.Merge(AllExtensionsSetText, + TestUtil.CreateExtensionRegistry(), + builder); + TestUtil.AssertAllExtensionsSet(builder.Build()); + } + + [Test] + public void ParseCompatibility() { + string original = "repeated_float: inf\n" + + "repeated_float: -inf\n" + + "repeated_float: nan\n" + + "repeated_float: inff\n" + + "repeated_float: -inff\n" + + "repeated_float: nanf\n" + + "repeated_float: 1.0f\n" + + "repeated_float: infinityf\n" + + "repeated_float: -Infinityf\n" + + "repeated_double: infinity\n" + + "repeated_double: -infinity\n" + + "repeated_double: nan\n"; + string canonical = "repeated_float: Infinity\n" + + "repeated_float: -Infinity\n" + + "repeated_float: NaN\n" + + "repeated_float: Infinity\n" + + "repeated_float: -Infinity\n" + + "repeated_float: NaN\n" + + "repeated_float: 1\n" + // Java has 1.0; this is fine + "repeated_float: Infinity\n" + + "repeated_float: -Infinity\n" + + "repeated_double: Infinity\n" + + "repeated_double: -Infinity\n" + + "repeated_double: NaN\n"; + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge(original, builder); + Assert.AreEqual(canonical, builder.Build().ToString()); + } + + [Test] + public void ParseExotic() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge(ExoticText, builder); + + // Too lazy to check things individually. Don't try to debug this + // if testPrintExotic() is Assert.Failing. + Assert.AreEqual(ExoticText, builder.Build().ToString()); + } + + [Test] + public void ParseMessageSet() { + ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance(); + extensionRegistry.Add(TestMessageSetExtension1.MessageSetExtension); + extensionRegistry.Add(TestMessageSetExtension2.MessageSetExtension); + + TestMessageSet.Builder builder = TestMessageSet.CreateBuilder(); + TextFormat.Merge(MessageSetText, extensionRegistry, builder); + TestMessageSet messageSet = builder.Build(); + + Assert.IsTrue(messageSet.HasExtension(TestMessageSetExtension1.MessageSetExtension)); + Assert.AreEqual(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I); + Assert.IsTrue(messageSet.HasExtension(TestMessageSetExtension2.MessageSetExtension)); + Assert.AreEqual("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str); + } + + [Test] + public void ParseNumericEnum() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge("optional_nested_enum: 2", builder); + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, builder.OptionalNestedEnum); + } + + [Test] + public void ParseAngleBrackets() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge("OptionalGroup: < a: 1 >", builder); + Assert.IsTrue(builder.HasOptionalGroup); + Assert.AreEqual(1, builder.OptionalGroup.A); + } + + [Test] + public void ParseComment() { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + TextFormat.Merge( + "# this is a comment\n" + + "optional_int32: 1 # another comment\n" + + "optional_int64: 2\n" + + "# EOF comment", builder); + Assert.AreEqual(1, builder.OptionalInt32); + Assert.AreEqual(2, builder.OptionalInt64); + } + + + private static void AssertParseError(string error, string text) { + TestAllTypes.Builder builder = TestAllTypes.CreateBuilder(); + try { + TextFormat.Merge(text, TestUtil.CreateExtensionRegistry(), builder); + Assert.Fail("Expected parse exception."); + } catch (FormatException e) { + Assert.AreEqual(error, e.Message); + } + } + + [Test] + public void ParseErrors() { + AssertParseError( + "1:16: Expected \":\".", + "optional_int32 123"); + AssertParseError( + "1:23: Expected identifier.", + "optional_nested_enum: ?"); + AssertParseError( + "1:18: Couldn't parse integer: Number must be positive: -1", + "optional_uint32: -1"); + AssertParseError( + "1:17: Couldn't parse integer: Number out of range for 32-bit signed " + + "integer: 82301481290849012385230157", + "optional_int32: 82301481290849012385230157"); + AssertParseError( + "1:16: Expected \"true\" or \"false\".", + "optional_bool: maybe"); + AssertParseError( + "1:18: Expected string.", + "optional_string: 123"); + AssertParseError( + "1:18: String missing ending quote.", + "optional_string: \"ueoauaoe"); + AssertParseError( + "1:18: String missing ending quote.", + "optional_string: \"ueoauaoe\n" + + "optional_int32: 123"); + AssertParseError( + "1:18: Invalid escape sequence: '\\z'", + "optional_string: \"\\z\""); + AssertParseError( + "1:18: String missing ending quote.", + "optional_string: \"ueoauaoe\n" + + "optional_int32: 123"); + AssertParseError( + "1:2: Extension \"nosuchext\" not found in the ExtensionRegistry.", + "[nosuchext]: 123"); + AssertParseError( + "1:20: Extension \"protobuf_unittest.optional_int32_extension\" does " + + "not extend message type \"protobuf_unittest.TestAllTypes\".", + "[protobuf_unittest.optional_int32_extension]: 123"); + AssertParseError( + "1:1: Message type \"protobuf_unittest.TestAllTypes\" has no field " + + "named \"nosuchfield\".", + "nosuchfield: 123"); + AssertParseError( + "1:21: Expected \">\".", + "OptionalGroup < a: 1"); + AssertParseError( + "1:23: Enum type \"protobuf_unittest.TestAllTypes.NestedEnum\" has no " + + "value named \"NO_SUCH_VALUE\".", + "optional_nested_enum: NO_SUCH_VALUE"); + AssertParseError( + "1:23: Enum type \"protobuf_unittest.TestAllTypes.NestedEnum\" has no " + + "value with number 123.", + "optional_nested_enum: 123"); + + // Delimiters must match. + AssertParseError( + "1:22: Expected identifier.", + "OptionalGroup < a: 1 }"); + AssertParseError( + "1:22: Expected identifier.", + "OptionalGroup { a: 1 >"); + } + + // ================================================================= + + private static ByteString Bytes(params byte[] bytes) { + return ByteString.CopyFrom(bytes); + } + + private delegate void FormattingAction(); + + private static void AssertFormatException(FormattingAction action) { + try { + action(); + Assert.Fail("Should have thrown an exception."); + } catch (FormatException) { + // success + } + } + + [Test] + public void Escape() { + // Escape sequences. + Assert.AreEqual("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"", + TextFormat.EscapeBytes(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\""))); + Assert.AreEqual("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"", + TextFormat.EscapeText("\0\u0001\u0007\b\f\n\r\t\v\\\'\"")); + Assert.AreEqual(Bytes("\0\u0001\u0007\b\f\n\r\t\v\\\'\""), + TextFormat.UnescapeBytes("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"")); + Assert.AreEqual("\0\u0001\u0007\b\f\n\r\t\v\\\'\"", + TextFormat.UnescapeText("\\000\\001\\a\\b\\f\\n\\r\\t\\v\\\\\\'\\\"")); + + // Unicode handling. + Assert.AreEqual("\\341\\210\\264", TextFormat.EscapeText("\u1234")); + Assert.AreEqual("\\341\\210\\264", TextFormat.EscapeBytes(Bytes(0xe1, 0x88, 0xb4))); + Assert.AreEqual("\u1234", TextFormat.UnescapeText("\\341\\210\\264")); + Assert.AreEqual(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\341\\210\\264")); + Assert.AreEqual("\u1234", TextFormat.UnescapeText("\\xe1\\x88\\xb4")); + Assert.AreEqual(Bytes(0xe1, 0x88, 0xb4), TextFormat.UnescapeBytes("\\xe1\\x88\\xb4")); + + // Errors. + AssertFormatException(() => TextFormat.UnescapeText("\\x")); + AssertFormatException(() => TextFormat.UnescapeText("\\z")); + AssertFormatException(() => TextFormat.UnescapeText("\\")); + } + + [Test] + public void ParseInteger() { + Assert.AreEqual( 0, TextFormat.ParseInt32( "0")); + Assert.AreEqual( 1, TextFormat.ParseInt32( "1")); + Assert.AreEqual( -1, TextFormat.ParseInt32( "-1")); + Assert.AreEqual( 12345, TextFormat.ParseInt32( "12345")); + Assert.AreEqual( -12345, TextFormat.ParseInt32( "-12345")); + Assert.AreEqual( 2147483647, TextFormat.ParseInt32( "2147483647")); + Assert.AreEqual(-2147483648, TextFormat.ParseInt32("-2147483648")); + + Assert.AreEqual( 0, TextFormat.ParseUInt32( "0")); + Assert.AreEqual( 1, TextFormat.ParseUInt32( "1")); + Assert.AreEqual( 12345, TextFormat.ParseUInt32( "12345")); + Assert.AreEqual( 2147483647, TextFormat.ParseUInt32("2147483647")); + Assert.AreEqual(2147483648U, TextFormat.ParseUInt32("2147483648")); + Assert.AreEqual(4294967295U, TextFormat.ParseUInt32("4294967295")); + + Assert.AreEqual( 0L, TextFormat.ParseInt64( "0")); + Assert.AreEqual( 1L, TextFormat.ParseInt64( "1")); + Assert.AreEqual( -1L, TextFormat.ParseInt64( "-1")); + Assert.AreEqual( 12345L, TextFormat.ParseInt64( "12345")); + Assert.AreEqual( -12345L, TextFormat.ParseInt64( "-12345")); + Assert.AreEqual( 2147483647L, TextFormat.ParseInt64( "2147483647")); + Assert.AreEqual(-2147483648L, TextFormat.ParseInt64("-2147483648")); + Assert.AreEqual( 4294967295L, TextFormat.ParseInt64( "4294967295")); + Assert.AreEqual( 4294967296L, TextFormat.ParseInt64( "4294967296")); + Assert.AreEqual(9223372036854775807L, TextFormat.ParseInt64("9223372036854775807")); + Assert.AreEqual(-9223372036854775808L, TextFormat.ParseInt64("-9223372036854775808")); + + Assert.AreEqual( 0L, TextFormat.ParseUInt64( "0")); + Assert.AreEqual( 1L, TextFormat.ParseUInt64( "1")); + Assert.AreEqual( 12345L, TextFormat.ParseUInt64( "12345")); + Assert.AreEqual( 2147483647L, TextFormat.ParseUInt64( "2147483647")); + Assert.AreEqual( 4294967295L, TextFormat.ParseUInt64( "4294967295")); + Assert.AreEqual( 4294967296L, TextFormat.ParseUInt64( "4294967296")); + Assert.AreEqual(9223372036854775807UL, TextFormat.ParseUInt64("9223372036854775807")); + Assert.AreEqual(9223372036854775808UL, TextFormat.ParseUInt64("9223372036854775808")); + Assert.AreEqual(18446744073709551615UL, TextFormat.ParseUInt64("18446744073709551615")); + + // Hex + Assert.AreEqual(0x1234abcd, TextFormat.ParseInt32("0x1234abcd")); + Assert.AreEqual(-0x1234abcd, TextFormat.ParseInt32("-0x1234abcd")); + Assert.AreEqual(0xffffffffffffffffUL, TextFormat.ParseUInt64("0xffffffffffffffff")); + Assert.AreEqual(0x7fffffffffffffffL, + TextFormat.ParseInt64("0x7fffffffffffffff")); + + // Octal + Assert.AreEqual(342391, TextFormat.ParseInt32("01234567")); + + // Out-of-range + AssertFormatException(() => TextFormat.ParseInt32("2147483648")); + AssertFormatException(() => TextFormat.ParseInt32("-2147483649")); + AssertFormatException(() => TextFormat.ParseUInt32("4294967296")); + AssertFormatException(() => TextFormat.ParseUInt32("-1")); + AssertFormatException(() => TextFormat.ParseInt64("9223372036854775808")); + AssertFormatException(() => TextFormat.ParseInt64("-9223372036854775809")); + AssertFormatException(() => TextFormat.ParseUInt64("18446744073709551616")); + AssertFormatException(() => TextFormat.ParseUInt64("-1")); + AssertFormatException(() => TextFormat.ParseInt32("abcd")); + } + } +} diff --git a/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs b/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs new file mode 100644 index 00000000..12ed4120 --- /dev/null +++ b/src/ProtocolBuffers.Test/UnknownFieldSetTest.cs @@ -0,0 +1,314 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class UnknownFieldSetTest { + + private MessageDescriptor descriptor; + private TestAllTypes allFields; + private ByteString allFieldsData; + + /// <summary> + /// An empty message that has been parsed from allFieldsData. So, it has + /// unknown fields of every type. + /// </summary> + private TestEmptyMessage emptyMessage; + private UnknownFieldSet unknownFields; + + [SetUp] + public void SetUp() { + descriptor = TestAllTypes.Descriptor; + allFields = TestUtil.GetAllSet(); + allFieldsData = allFields.ToByteString(); + emptyMessage = TestEmptyMessage.ParseFrom(allFieldsData); + unknownFields = emptyMessage.UnknownFields; + } + + private UnknownField GetField(String name) { + FieldDescriptor field = descriptor.FindDescriptor<FieldDescriptor>(name); + Assert.IsNotNull(field); + return unknownFields.FieldDictionary[field.FieldNumber]; + } + + /// <summary> + /// Constructs a protocol buffer which contains fields with all the same + /// numbers as allFieldsData except that each field is some other wire + /// type. + /// </summary> + private ByteString GetBizarroData() { + UnknownFieldSet.Builder bizarroFields = UnknownFieldSet.CreateBuilder(); + + UnknownField varintField = UnknownField.CreateBuilder().AddVarint(1).Build(); + UnknownField fixed32Field = UnknownField.CreateBuilder().AddFixed32(1).Build(); + + foreach (KeyValuePair<int, UnknownField> entry in unknownFields.FieldDictionary) { + if (entry.Value.VarintList.Count == 0) { + // Original field is not a varint, so use a varint. + bizarroFields.AddField(entry.Key, varintField); + } else { + // Original field *is* a varint, so use something else. + bizarroFields.AddField(entry.Key, fixed32Field); + } + } + + return bizarroFields.Build().ToByteString(); + } + + // ================================================================= + + [Test] + public void Varint() { + UnknownField field = GetField("optional_int32"); + Assert.AreEqual(1, field.VarintList.Count); + Assert.AreEqual(allFields.OptionalInt32, (long) field.VarintList[0]); + } + + [Test] + public void Fixed32() { + UnknownField field = GetField("optional_fixed32"); + Assert.AreEqual(1, field.Fixed32List.Count); + Assert.AreEqual(allFields.OptionalFixed32, (int) field.Fixed32List[0]); + } + + [Test] + public void Fixed64() { + UnknownField field = GetField("optional_fixed64"); + Assert.AreEqual(1, field.Fixed64List.Count); + Assert.AreEqual(allFields.OptionalFixed64, (long) field.Fixed64List[0]); + } + + [Test] + public void LengthDelimited() { + UnknownField field = GetField("optional_bytes"); + Assert.AreEqual(1, field.LengthDelimitedList.Count); + Assert.AreEqual(allFields.OptionalBytes, field.LengthDelimitedList[0]); + } + + [Test] + public void Group() { + FieldDescriptor nestedFieldDescriptor = + TestAllTypes.Types.OptionalGroup.Descriptor.FindDescriptor<FieldDescriptor>("a"); + Assert.IsNotNull(nestedFieldDescriptor); + + UnknownField field = GetField("optionalgroup"); + Assert.AreEqual(1, field.GroupList.Count); + + UnknownFieldSet group = field.GroupList[0]; + Assert.AreEqual(1, group.FieldDictionary.Count); + Assert.IsTrue(group.HasField(nestedFieldDescriptor.FieldNumber)); + + UnknownField nestedField = group[nestedFieldDescriptor.FieldNumber]; + Assert.AreEqual(1, nestedField.VarintList.Count); + Assert.AreEqual(allFields.OptionalGroup.A, (long) nestedField.VarintList[0]); + } + + [Test] + public void Serialize() { + // Check that serializing the UnknownFieldSet produces the original data again. + ByteString data = emptyMessage.ToByteString(); + Assert.AreEqual(allFieldsData, data); + } + + [Test] + public void CopyFrom() { + TestEmptyMessage message = + TestEmptyMessage.CreateBuilder().MergeFrom(emptyMessage).Build(); + + Assert.AreEqual(emptyMessage.ToString(), message.ToString()); + } + + [Test] + public void MergeFrom() { + TestEmptyMessage source = + TestEmptyMessage.CreateBuilder() + .SetUnknownFields( + UnknownFieldSet.CreateBuilder() + .AddField(2, + UnknownField.CreateBuilder() + .AddVarint(2).Build()) + .AddField(3, + UnknownField.CreateBuilder() + .AddVarint(4).Build()) + .Build()) + .Build(); + TestEmptyMessage destination = + TestEmptyMessage.CreateBuilder() + .SetUnknownFields( + UnknownFieldSet.CreateBuilder() + .AddField(1, + UnknownField.CreateBuilder() + .AddVarint(1).Build()) + .AddField(3, + UnknownField.CreateBuilder() + .AddVarint(3).Build()) + .Build()) + .MergeFrom(source) + .Build(); + + Assert.AreEqual( + "1: 1\n" + + "2: 2\n" + + "3: 3\n" + + "3: 4\n", + destination.ToString()); + } + + [Test] + public void Clear() { + UnknownFieldSet fields = + UnknownFieldSet.CreateBuilder().MergeFrom(unknownFields).Clear().Build(); + Assert.AreEqual(0, fields.FieldDictionary.Count); + } + + [Test] + public void ClearMessage() { + TestEmptyMessage message = + TestEmptyMessage.CreateBuilder().MergeFrom(emptyMessage).Clear().Build(); + Assert.AreEqual(0, message.SerializedSize); + } + + [Test] + public void ParseKnownAndUnknown() { + // Test mixing known and unknown fields when parsing. + + UnknownFieldSet fields = + UnknownFieldSet.CreateBuilder(unknownFields) + .AddField(123456, + UnknownField.CreateBuilder().AddVarint(654321).Build()) + .Build(); + + ByteString data = fields.ToByteString(); + TestAllTypes destination = TestAllTypes.ParseFrom(data); + + TestUtil.AssertAllFieldsSet(destination); + Assert.AreEqual(1, destination.UnknownFields.FieldDictionary.Count); + + UnknownField field = destination.UnknownFields[123456]; + Assert.AreEqual(1, field.VarintList.Count); + Assert.AreEqual(654321, (long) field.VarintList[0]); + } + + [Test] + public void WrongTypeTreatedAsUnknown() { + // Test that fields of the wrong wire type are treated like unknown fields + // when parsing. + + ByteString bizarroData = GetBizarroData(); + TestAllTypes allTypesMessage = TestAllTypes.ParseFrom(bizarroData); + TestEmptyMessage emptyMessage = TestEmptyMessage.ParseFrom(bizarroData); + + // All fields should have been interpreted as unknown, so the debug strings + // should be the same. + Assert.AreEqual(emptyMessage.ToString(), allTypesMessage.ToString()); + } + + [Test] + public void UnknownExtensions() { + // Make sure fields are properly parsed to the UnknownFieldSet even when + // they are declared as extension numbers. + + TestEmptyMessageWithExtensions message = + TestEmptyMessageWithExtensions.ParseFrom(allFieldsData); + + Assert.AreEqual(unknownFields.FieldDictionary.Count, + message.UnknownFields.FieldDictionary.Count); + Assert.AreEqual(allFieldsData, message.ToByteString()); + } + + [Test] + public void WrongExtensionTypeTreatedAsUnknown() { + // Test that fields of the wrong wire type are treated like unknown fields + // when parsing extensions. + + ByteString bizarroData = GetBizarroData(); + TestAllExtensions allExtensionsMessage = TestAllExtensions.ParseFrom(bizarroData); + TestEmptyMessage emptyMessage = TestEmptyMessage.ParseFrom(bizarroData); + + // All fields should have been interpreted as unknown, so the debug strings + // should be the same. + Assert.AreEqual(emptyMessage.ToString(), + allExtensionsMessage.ToString()); + } + + [Test] + public void ParseUnknownEnumValue() { + FieldDescriptor singularField = TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("optional_nested_enum"); + FieldDescriptor repeatedField = TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("repeated_nested_enum"); + Assert.IsNotNull(singularField); + Assert.IsNotNull(repeatedField); + + ByteString data = + UnknownFieldSet.CreateBuilder() + .AddField(singularField.FieldNumber, + UnknownField.CreateBuilder() + .AddVarint((int) TestAllTypes.Types.NestedEnum.BAR) + .AddVarint(5) // not valid + .Build()) + .AddField(repeatedField.FieldNumber, + UnknownField.CreateBuilder() + .AddVarint((int) TestAllTypes.Types.NestedEnum.FOO) + .AddVarint(4) // not valid + .AddVarint((int) TestAllTypes.Types.NestedEnum.BAZ) + .AddVarint(6) // not valid + .Build()) + .Build() + .ToByteString(); + + { + TestAllTypes message = TestAllTypes.ParseFrom(data); + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, + message.OptionalNestedEnum); + TestUtil.AssertEqual(new [] {TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.BAZ}, + message.RepeatedNestedEnumList); + TestUtil.AssertEqual(new[] {5UL}, message.UnknownFields[singularField.FieldNumber].VarintList); + TestUtil.AssertEqual(new[] {4UL, 6UL}, message.UnknownFields[repeatedField.FieldNumber].VarintList); + } + + { + TestAllExtensions message = + TestAllExtensions.ParseFrom(data, TestUtil.CreateExtensionRegistry()); + Assert.AreEqual(TestAllTypes.Types.NestedEnum.BAR, + message.GetExtension(UnitTestProtoFile.OptionalNestedEnumExtension)); + TestUtil.AssertEqual(new[] { TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.BAZ }, + message.GetExtension(UnitTestProtoFile.RepeatedNestedEnumExtension)); + TestUtil.AssertEqual(new[] { 5UL }, message.UnknownFields[singularField.FieldNumber].VarintList); + TestUtil.AssertEqual(new[] { 4UL, 6UL }, message.UnknownFields[repeatedField.FieldNumber].VarintList); + } + } + + [Test] + public void LargeVarint() { + ByteString data = + UnknownFieldSet.CreateBuilder() + .AddField(1, + UnknownField.CreateBuilder() + .AddVarint(0x7FFFFFFFFFFFFFFFL) + .Build()) + .Build() + .ToByteString(); + UnknownFieldSet parsed = UnknownFieldSet.ParseFrom(data); + UnknownField field = parsed[1]; + Assert.AreEqual(1, field.VarintList.Count); + Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, field.VarintList[0]); + } + } +} diff --git a/src/ProtocolBuffers.Test/WireFormatTest.cs b/src/ProtocolBuffers.Test/WireFormatTest.cs new file mode 100644 index 00000000..c5fc3e41 --- /dev/null +++ b/src/ProtocolBuffers.Test/WireFormatTest.cs @@ -0,0 +1,228 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Reflection; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.TestProtos; +using NUnit.Framework; + +namespace Google.ProtocolBuffers { + [TestFixture] + public class WireFormatTest { + + /// <summary> + /// Keeps the attributes on FieldType and the switch statement in WireFormat in sync. + /// </summary> + [Test] + public void FieldTypeToWireTypeMapping() { + foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public)) { + FieldType fieldType = (FieldType)field.GetValue(null); + FieldMappingAttribute mapping = (FieldMappingAttribute)field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0]; + Assert.AreEqual(mapping.WireType, WireFormat.GetWireType(fieldType)); + } + } + + [Test] + public void Serialization() { + TestAllTypes message = TestUtil.GetAllSet(); + + ByteString rawBytes = message.ToByteString(); + Assert.AreEqual(rawBytes.Length, message.SerializedSize); + + TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); + + TestUtil.AssertAllFieldsSet(message2); + } + + [Test] + public void SerializeExtensions() { + // TestAllTypes and TestAllExtensions should have compatible wire formats, + // so if we serealize a TestAllExtensions then parse it as TestAllTypes + // it should work. + + TestAllExtensions message = TestUtil.GetAllExtensionsSet(); + ByteString rawBytes = message.ToByteString(); + Assert.AreEqual(rawBytes.Length, message.SerializedSize); + + TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes); + + TestUtil.AssertAllFieldsSet(message2); + } + + [Test] + public void ParseExtensions() { + // TestAllTypes and TestAllExtensions should have compatible wire formats, + // so if we serealize a TestAllTypes then parse it as TestAllExtensions + // it should work. + + TestAllTypes message = TestUtil.GetAllSet(); + ByteString rawBytes = message.ToByteString(); + + ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); + TestUtil.RegisterAllExtensions(registry); + registry = registry.AsReadOnly(); + + TestAllExtensions message2 = + TestAllExtensions.ParseFrom(rawBytes, registry); + + TestUtil.AssertAllExtensionsSet(message2); + } + + [Test] + public void ExtensionsSerializedSize() { + Assert.AreEqual(TestUtil.GetAllSet().SerializedSize, TestUtil.GetAllExtensionsSet().SerializedSize); + } + + private void AssertFieldsInOrder(ByteString data) { + CodedInputStream input = data.CreateCodedInput(); + uint previousTag = 0; + + while (true) { + uint tag = input.ReadTag(); + if (tag == 0) { + break; + } + + Assert.IsTrue(tag > previousTag); + previousTag = tag; + input.SkipField(tag); + } + } + + [Test] + public void InterleavedFieldsAndExtensions() { + // Tests that fields are written in order even when extension ranges + // are interleaved with field numbers. + ByteString data = + TestFieldOrderings.CreateBuilder() + .SetMyInt(1) + .SetMyString("foo") + .SetMyFloat(1.0F) + .SetExtension(UnitTestProtoFile.MyExtensionInt, 23) + .SetExtension(UnitTestProtoFile.MyExtensionString, "bar") + .Build().ToByteString(); + AssertFieldsInOrder(data); + + MessageDescriptor descriptor = TestFieldOrderings.Descriptor; + ByteString dynamic_data = + DynamicMessage.CreateBuilder(TestFieldOrderings.Descriptor) + .SetField(descriptor.FindDescriptor<FieldDescriptor>("my_int"), 1L) + .SetField(descriptor.FindDescriptor<FieldDescriptor>("my_string"), "foo") + .SetField(descriptor.FindDescriptor<FieldDescriptor>("my_float"), 1.0F) + .SetField(UnitTestProtoFile.MyExtensionInt.Descriptor, 23) + .SetField(UnitTestProtoFile.MyExtensionString.Descriptor, "bar") + .WeakBuild().ToByteString(); + AssertFieldsInOrder(dynamic_data); + } + + private const int UnknownTypeId = 1550055; + private static readonly int TypeId1 = TestMessageSetExtension1.Descriptor.Extensions[0].FieldNumber; + private static readonly int TypeId2 = TestMessageSetExtension2.Descriptor.Extensions[0].FieldNumber; + + [Test] + public void SerializeMessageSet() { + // Set up a TestMessageSet with two known messages and an unknown one. + TestMessageSet messageSet = + TestMessageSet.CreateBuilder() + .SetExtension( + TestMessageSetExtension1.MessageSetExtension, + TestMessageSetExtension1.CreateBuilder().SetI(123).Build()) + .SetExtension( + TestMessageSetExtension2.MessageSetExtension, + TestMessageSetExtension2.CreateBuilder().SetStr("foo").Build()) + .SetUnknownFields( + UnknownFieldSet.CreateBuilder() + .AddField(UnknownTypeId, + UnknownField.CreateBuilder() + .AddLengthDelimited(ByteString.CopyFromUtf8("bar")) + .Build()) + .Build()) + .Build(); + + ByteString data = messageSet.ToByteString(); + + // Parse back using RawMessageSet and check the contents. + RawMessageSet raw = RawMessageSet.ParseFrom(data); + + Assert.AreEqual(0, raw.UnknownFields.FieldDictionary.Count); + + Assert.AreEqual(3, raw.ItemCount); + Assert.AreEqual(TypeId1, raw.ItemList[0].TypeId); + Assert.AreEqual(TypeId2, raw.ItemList[1].TypeId); + Assert.AreEqual(UnknownTypeId, raw.ItemList[2].TypeId); + + TestMessageSetExtension1 message1 = TestMessageSetExtension1.ParseFrom(raw.GetItem(0).Message.ToByteArray()); + Assert.AreEqual(123, message1.I); + + TestMessageSetExtension2 message2 = TestMessageSetExtension2.ParseFrom(raw.GetItem(1).Message.ToByteArray()); + Assert.AreEqual("foo", message2.Str); + + Assert.AreEqual("bar", raw.GetItem(2).Message.ToStringUtf8()); + } + + [Test] + public void ParseMessageSet() { + ExtensionRegistry extensionRegistry = ExtensionRegistry.CreateInstance(); + extensionRegistry.Add(TestMessageSetExtension1.MessageSetExtension); + extensionRegistry.Add(TestMessageSetExtension2.MessageSetExtension); + + // Set up a RawMessageSet with two known messages and an unknown one. + RawMessageSet raw = + RawMessageSet.CreateBuilder() + .AddItem( + RawMessageSet.Types.Item.CreateBuilder() + .SetTypeId(TypeId1) + .SetMessage( + TestMessageSetExtension1.CreateBuilder() + .SetI(123) + .Build().ToByteString()) + .Build()) + .AddItem( + RawMessageSet.Types.Item.CreateBuilder() + .SetTypeId(TypeId2) + .SetMessage( + TestMessageSetExtension2.CreateBuilder() + .SetStr("foo") + .Build().ToByteString()) + .Build()) + .AddItem( + RawMessageSet.Types.Item.CreateBuilder() + .SetTypeId(UnknownTypeId) + .SetMessage(ByteString.CopyFromUtf8("bar")) + .Build()) + .Build(); + + ByteString data = raw.ToByteString(); + + // Parse as a TestMessageSet and check the contents. + TestMessageSet messageSet = + TestMessageSet.ParseFrom(data, extensionRegistry); + + Assert.AreEqual(123, messageSet.GetExtension(TestMessageSetExtension1.MessageSetExtension).I); + Assert.AreEqual("foo", messageSet.GetExtension(TestMessageSetExtension2.MessageSetExtension).Str); + + // Check for unknown field with type LENGTH_DELIMITED, + // number UNKNOWN_TYPE_ID, and contents "bar". + UnknownFieldSet unknownFields = messageSet.UnknownFields; + Assert.AreEqual(1, unknownFields.FieldDictionary.Count); + Assert.IsTrue(unknownFields.HasField(UnknownTypeId)); + + UnknownField field = unknownFields[UnknownTypeId]; + Assert.AreEqual(1, field.LengthDelimitedList.Count); + Assert.AreEqual("bar", field.LengthDelimitedList[0].ToStringUtf8()); + } + + } +} diff --git a/src/ProtocolBuffers.sln b/src/ProtocolBuffers.sln new file mode 100644 index 00000000..c4f9877b --- /dev/null +++ b/src/ProtocolBuffers.sln @@ -0,0 +1,38 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtocolBuffers", "ProtocolBuffers\ProtocolBuffers.csproj", "{6908BDCE-D925-43F3-94AC-A531E6DF2591}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtocolBuffers.Test", "ProtocolBuffers.Test\ProtocolBuffers.Test.csproj", "{DD01ED24-3750-4567-9A23-1DB676A15610}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoGen", "ProtoGen\ProtoGen.csproj", "{250ADE34-82FD-4BAE-86D5-985FBE589C4A}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtoGen.Test", "ProtoGen.Test\ProtoGen.Test.csproj", "{C268DA4C-4004-47DA-AF23-44C983281A68}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {6908BDCE-D925-43F3-94AC-A531E6DF2591}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6908BDCE-D925-43F3-94AC-A531E6DF2591}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6908BDCE-D925-43F3-94AC-A531E6DF2591}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6908BDCE-D925-43F3-94AC-A531E6DF2591}.Release|Any CPU.Build.0 = Release|Any CPU + {DD01ED24-3750-4567-9A23-1DB676A15610}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {DD01ED24-3750-4567-9A23-1DB676A15610}.Debug|Any CPU.Build.0 = Debug|Any CPU + {DD01ED24-3750-4567-9A23-1DB676A15610}.Release|Any CPU.ActiveCfg = Release|Any CPU + {DD01ED24-3750-4567-9A23-1DB676A15610}.Release|Any CPU.Build.0 = Release|Any CPU + {250ADE34-82FD-4BAE-86D5-985FBE589C4A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {250ADE34-82FD-4BAE-86D5-985FBE589C4A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {250ADE34-82FD-4BAE-86D5-985FBE589C4A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {250ADE34-82FD-4BAE-86D5-985FBE589C4A}.Release|Any CPU.Build.0 = Release|Any CPU + {C268DA4C-4004-47DA-AF23-44C983281A68}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C268DA4C-4004-47DA-AF23-44C983281A68}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C268DA4C-4004-47DA-AF23-44C983281A68}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C268DA4C-4004-47DA-AF23-44C983281A68}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/src/ProtocolBuffers/AbstractBuilder.cs b/src/ProtocolBuffers/AbstractBuilder.cs new file mode 100644 index 00000000..11a82974 --- /dev/null +++ b/src/ProtocolBuffers/AbstractBuilder.cs @@ -0,0 +1,222 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Implementation of the non-generic IMessage interface as far as possible. + /// </summary> + public abstract class AbstractBuilder<TMessage, TBuilder> : IBuilder<TMessage, TBuilder> + where TMessage : AbstractMessage<TMessage, TBuilder> + where TBuilder : AbstractBuilder<TMessage, TBuilder> { + + protected abstract TBuilder ThisBuilder { get; } + + #region Unimplemented members of IBuilder + public abstract UnknownFieldSet UnknownFields { get; set; } + public abstract TBuilder MergeFrom(TMessage other); + public abstract bool IsInitialized { get; } + public abstract IDictionary<FieldDescriptor, object> AllFields { get; } + public abstract object this[FieldDescriptor field] { get; set; } + public abstract MessageDescriptor DescriptorForType { get; } + public abstract int GetRepeatedFieldCount(FieldDescriptor field); + public abstract object this[FieldDescriptor field, int index] { get; set; } + public abstract bool HasField(FieldDescriptor field); + public abstract TMessage Build(); + public abstract TMessage BuildPartial(); + public abstract TBuilder Clone(); + public abstract TMessage DefaultInstanceForType { get; } + public abstract IBuilder CreateBuilderForField(FieldDescriptor field); + public abstract TBuilder ClearField(FieldDescriptor field); + public abstract TBuilder AddRepeatedField(FieldDescriptor field, object value); + #endregion + + #region Implementation of methods which don't require type parameter information + public IMessage WeakBuild() { + return Build(); + } + + public IBuilder WeakAddRepeatedField(FieldDescriptor field, object value) { + return AddRepeatedField(field, value); + } + + public IBuilder WeakClear() { + return Clear(); + } + + public IBuilder WeakMergeFrom(IMessage message) { + return MergeFrom(message); + } + + public IBuilder WeakMergeFrom(CodedInputStream input) { + return MergeFrom(input); + } + + public IBuilder WeakMergeFrom(CodedInputStream input, ExtensionRegistry registry) { + return MergeFrom(input, registry); + } + + public IBuilder WeakMergeFrom(ByteString data) { + return MergeFrom(data); + } + + public IBuilder WeakMergeFrom(ByteString data, ExtensionRegistry registry) { + return MergeFrom(data, registry); + } + + public IMessage WeakBuildPartial() { + return BuildPartial(); + } + + public IBuilder WeakClone() { + return Clone(); + } + + public IMessage WeakDefaultInstanceForType { + get { return DefaultInstanceForType; } + } + + public IBuilder WeakClearField(FieldDescriptor field) { + return ClearField(field); + } + #endregion + + public TBuilder SetUnknownFields(UnknownFieldSet fields) { + UnknownFields = fields; + return ThisBuilder; + } + + public virtual TBuilder Clear() { + foreach(FieldDescriptor field in AllFields.Keys) { + ClearField(field); + } + return ThisBuilder; + } + + public virtual TBuilder MergeFrom(IMessage other) { + if (other.DescriptorForType != DescriptorForType) { + throw new ArgumentException("MergeFrom(IMessage) can only merge messages of the same type."); + } + + // Note: We don't attempt to verify that other's fields have valid + // types. Doing so would be a losing battle. We'd have to verify + // all sub-messages as well, and we'd have to make copies of all of + // them to insure that they don't change after verification (since + // the Message interface itself cannot enforce immutability of + // implementations). + // TODO(jonskeet): Provide a function somewhere called MakeDeepCopy() + // which allows people to make secure deep copies of messages. + foreach (KeyValuePair<FieldDescriptor, object> entry in other.AllFields) { + FieldDescriptor field = entry.Key; + if (field.IsRepeated) { + // Concatenate repeated fields + foreach (object element in (IEnumerable) entry.Value) { + AddRepeatedField(field, element); + } + } else if (field.MappedType == MappedType.Message) { + // Merge singular messages + IMessage existingValue = (IMessage) this[field]; + if (existingValue == existingValue.WeakDefaultInstanceForType) { + this[field] = entry.Value; + } else { + this[field] = existingValue.WeakCreateBuilderForType() + .WeakMergeFrom(existingValue) + .WeakMergeFrom((IMessage) entry.Value) + .WeakBuild(); + } + } else { + // Overwrite simple values + this[field] = entry.Value; + } + } + return ThisBuilder; + } + + public virtual TBuilder MergeFrom(CodedInputStream input) { + return MergeFrom(input, ExtensionRegistry.Empty); + } + + public virtual TBuilder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry) { + UnknownFieldSet.Builder unknownFields = UnknownFieldSet.CreateBuilder(UnknownFields); + unknownFields.MergeFrom(input, extensionRegistry, this); + UnknownFields = unknownFields.Build(); + return ThisBuilder; + } + + public virtual TBuilder MergeUnknownFields(UnknownFieldSet unknownFields) { + UnknownFields = UnknownFieldSet.CreateBuilder(UnknownFields) + .MergeFrom(unknownFields) + .Build(); + return ThisBuilder; + } + + public virtual TBuilder MergeFrom(ByteString data) { + CodedInputStream input = data.CreateCodedInput(); + MergeFrom(input); + input.CheckLastTagWas(0); + return ThisBuilder; + } + + public virtual TBuilder MergeFrom(ByteString data, ExtensionRegistry extensionRegistry) { + CodedInputStream input = data.CreateCodedInput(); + MergeFrom(input, extensionRegistry); + input.CheckLastTagWas(0); + return ThisBuilder; + } + + public virtual TBuilder MergeFrom(byte[] data) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + MergeFrom(input); + input.CheckLastTagWas(0); + return ThisBuilder; + } + + public virtual TBuilder MergeFrom(byte[] data, ExtensionRegistry extensionRegistry) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + MergeFrom(input, extensionRegistry); + input.CheckLastTagWas(0); + return ThisBuilder; + } + + public virtual TBuilder MergeFrom(Stream input) { + CodedInputStream codedInput = CodedInputStream.CreateInstance(input); + MergeFrom(codedInput); + codedInput.CheckLastTagWas(0); + return ThisBuilder; + } + + public virtual TBuilder MergeFrom(Stream input, ExtensionRegistry extensionRegistry) { + CodedInputStream codedInput = CodedInputStream.CreateInstance(input); + MergeFrom(codedInput, extensionRegistry); + codedInput.CheckLastTagWas(0); + return ThisBuilder; + } + + public virtual IBuilder SetField(FieldDescriptor field, object value) { + this[field] = value; + return ThisBuilder; + } + + public virtual IBuilder SetRepeatedField(FieldDescriptor field, int index, object value) { + this[field, index] = value; + return ThisBuilder; + } + } +} diff --git a/src/ProtocolBuffers/AbstractMessage.cs b/src/ProtocolBuffers/AbstractMessage.cs new file mode 100644 index 00000000..d8b9e9e6 --- /dev/null +++ b/src/ProtocolBuffers/AbstractMessage.cs @@ -0,0 +1,181 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections; +using System.Collections.Generic; +using System.IO; +using Google.ProtocolBuffers.Collections; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Implementation of the non-generic IMessage interface as far as possible. + /// </summary> + public abstract class AbstractMessage<TMessage, TBuilder> : IMessage<TMessage, TBuilder> + where TMessage : AbstractMessage<TMessage, TBuilder> + where TBuilder : AbstractBuilder<TMessage, TBuilder> { + /// <summary> + /// The serialized size if it's already been computed, or null + /// if we haven't computed it yet. + /// </summary> + private int? memoizedSize = null; + + #region Unimplemented members of IMessage + public abstract MessageDescriptor DescriptorForType { get; } + public abstract IDictionary<FieldDescriptor, object> AllFields { get; } + public abstract bool HasField(FieldDescriptor field); + public abstract object this[FieldDescriptor field] { get; } + public abstract int GetRepeatedFieldCount(FieldDescriptor field); + public abstract object this[FieldDescriptor field, int index] { get; } + public abstract UnknownFieldSet UnknownFields { get; } + public abstract TMessage DefaultInstanceForType { get; } + public abstract TBuilder CreateBuilderForType(); + #endregion + + public IBuilder WeakCreateBuilderForType() { + return CreateBuilderForType(); + } + + public IMessage WeakDefaultInstanceForType { + get { return DefaultInstanceForType; } + } + + public virtual bool IsInitialized { + get { + // Check that all required fields are present. + foreach (FieldDescriptor field in DescriptorForType.Fields) { + if (field.IsRequired && !HasField(field)) { + return false; + } + } + + // Check that embedded messages are initialized. + foreach (KeyValuePair<FieldDescriptor, object> entry in AllFields) { + FieldDescriptor field = entry.Key; + if (field.MappedType == MappedType.Message) { + if (field.IsRepeated) { + // We know it's an IList<T>, but not the exact type - so + // IEnumerable is the best we can do. (C# generics aren't covariant yet.) + foreach (IMessage element in (IEnumerable) entry.Value) { + if (!element.IsInitialized) { + return false; + } + } + } else { + if (!((IMessage)entry.Value).IsInitialized) { + return false; + } + } + } + } + return true; + } + } + + public sealed override string ToString() { + return TextFormat.PrintToString(this); + } + + public virtual void WriteTo(CodedOutputStream output) { + foreach (KeyValuePair<FieldDescriptor, object> entry in AllFields) { + FieldDescriptor field = entry.Key; + if (field.IsRepeated) { + // We know it's an IList<T>, but not the exact type - so + // IEnumerable is the best we can do. (C# generics aren't covariant yet.) + foreach (object element in (IEnumerable)entry.Value) { + output.WriteField(field.FieldType, field.FieldNumber, element); + } + } else { + output.WriteField(field.FieldType, field.FieldNumber, entry.Value); + } + } + + UnknownFieldSet unknownFields = UnknownFields; + if (DescriptorForType.Options.MessageSetWireFormat) { + unknownFields.WriteAsMessageSetTo(output); + } else { + unknownFields.WriteTo(output); + } + } + + public virtual int SerializedSize { + get { + if (memoizedSize != null) { + return memoizedSize.Value; + } + + int size = 0; + foreach (KeyValuePair<FieldDescriptor, object> entry in AllFields) { + FieldDescriptor field = entry.Key; + if (field.IsRepeated) { + foreach (object element in (IEnumerable) entry.Value) { + size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, element); + } + } else { + size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, entry.Value); + } + } + + UnknownFieldSet unknownFields = UnknownFields; + if (DescriptorForType.Options.MessageSetWireFormat) { + size += unknownFields.SerializedSizeAsMessageSet; + } else { + size += unknownFields.SerializedSize; + } + + memoizedSize = size; + return size; + } + } + + public ByteString ToByteString() { + ByteString.CodedBuilder output = new ByteString.CodedBuilder(SerializedSize); + WriteTo(output.CodedOutput); + return output.Build(); + } + + public byte[] ToByteArray() { + byte[] result = new byte[SerializedSize]; + CodedOutputStream output = CodedOutputStream.CreateInstance(result); + WriteTo(output); + output.CheckNoSpaceLeft(); + return result; + } + + public void WriteTo(Stream output) { + CodedOutputStream codedOutput = CodedOutputStream.CreateInstance(output); + WriteTo(codedOutput); + codedOutput.Flush(); + } + + public override bool Equals(object other) { + if (other == this) { + return true; + } + IMessage otherMessage = other as IMessage; + if (otherMessage == null || otherMessage.DescriptorForType != DescriptorForType) { + return false; + } + return Dictionaries.Equals(AllFields, otherMessage.AllFields); + } + + public override int GetHashCode() { + int hash = 41; + hash = (19 * hash) + DescriptorForType.GetHashCode(); + hash = (53 * hash) + Dictionaries.GetHashCode(AllFields); + return hash; + } + } +} diff --git a/src/ProtocolBuffers/ByteString.cs b/src/ProtocolBuffers/ByteString.cs new file mode 100644 index 00000000..26816d9c --- /dev/null +++ b/src/ProtocolBuffers/ByteString.cs @@ -0,0 +1,187 @@ +using System; +using System.Collections; +using System.Collections.Generic; +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Text; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Immutable array of bytes. + /// TODO(jonskeet): Implement the common collection interfaces? + /// </summary> + public sealed class ByteString : IEnumerable<byte>, IEquatable<ByteString> { + + private static readonly ByteString empty = new ByteString(new byte[0]); + + private readonly byte[] bytes; + + /// <summary> + /// Constructs a new ByteString from the given byte array. The array is + /// *not* copied, and must not be modified after this constructor is called. + /// </summary> + private ByteString(byte[] bytes) { + this.bytes = bytes; + } + + /// <summary> + /// Returns an empty ByteString. + /// </summary> + public static ByteString Empty { + get { return empty; } + } + + /// <summary> + /// Returns the length of this ByteString in bytes. + /// </summary> + public int Length { + get { return bytes.Length; } + } + + public bool IsEmpty { + get { return Length == 0; } + } + + public byte[] ToByteArray() { + return (byte[])bytes.Clone(); + } + + /// <summary> + /// Constructs a ByteString from the given array. The contents + /// are copied, so further modifications to the array will not + /// be reflected in the returned ByteString. + /// </summary> + public static ByteString CopyFrom(byte[] bytes) { + return new ByteString((byte[]) bytes.Clone()); + } + + /// <summary> + /// Constructs a ByteString from a portion of a byte array. + /// </summary> + public static ByteString CopyFrom(byte[] bytes, int offset, int count) { + byte[] portion = new byte[count]; + Array.Copy(bytes, offset, portion, 0, count); + return new ByteString(portion); + } + + /// <summary> + /// Creates a new ByteString by encoding the specified text with + /// the given encoding. + /// </summary> + public static ByteString CopyFrom(string text, Encoding encoding) { + return new ByteString(encoding.GetBytes(text)); + } + + /// <summary> + /// Creates a new ByteString by encoding the specified text in UTF-8. + /// </summary> + public static ByteString CopyFromUtf8(string text) { + return CopyFrom(text, Encoding.UTF8); + } + + /// <summary> + /// Retuns the byte at the given index. + /// </summary> + public byte this[int index] { + get { return bytes[index]; } + } + + public string ToString(Encoding encoding) { + return encoding.GetString(bytes); + } + + public string ToStringUtf8() { + return ToString(Encoding.UTF8); + } + + public IEnumerator<byte> GetEnumerator() { + return ((IEnumerable<byte>) bytes).GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() { + return GetEnumerator(); + } + + /// <summary> + /// Creates a CodedInputStream from this ByteString's data. + /// </summary> + public CodedInputStream CreateCodedInput() { + + // We trust CodedInputStream not to reveal the provided byte array or modify it + return CodedInputStream.CreateInstance(bytes); + } + + // TODO(jonskeet): CopyTo if it turns out to be required + + public override bool Equals(object obj) { + ByteString other = obj as ByteString; + if (obj == null) { + return false; + } + return Equals(other); + } + + public override int GetHashCode() { + int ret = 23; + foreach (byte b in bytes) { + ret = (ret << 8) | b; + } + return ret; + } + + public bool Equals(ByteString other) { + if (other.bytes.Length != bytes.Length) { + return false; + } + for (int i = 0; i < bytes.Length; i++) { + if (other.bytes[i] != bytes[i]) { + return false; + } + } + return true; + } + + /// <summary> + /// Builder for ByteStrings which allows them to be created without extra + /// copying being involved. This has to be a nested type in order to have access + /// to the private ByteString constructor. + /// </summary> + internal sealed class CodedBuilder { + private readonly CodedOutputStream output; + private readonly byte[] buffer; + + internal CodedBuilder(int size) { + buffer = new byte[size]; + output = CodedOutputStream.CreateInstance(buffer); + } + + public ByteString Build() { + output.CheckNoSpaceLeft(); + + // We can be confident that the CodedOutputStream will not modify the + // underlying bytes anymore because it already wrote all of them. So, + // no need to make a copy. + return new ByteString(buffer); + } + + public CodedOutputStream CodedOutput { + get { + return output; + } + } + } + } +} diff --git a/src/ProtocolBuffers/CodedInputStream.cs b/src/ProtocolBuffers/CodedInputStream.cs new file mode 100644 index 00000000..30969820 --- /dev/null +++ b/src/ProtocolBuffers/CodedInputStream.cs @@ -0,0 +1,843 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// Readings and decodes protocol message fields. + /// </summary> + /// <remarks> + /// This class contains two kinds of methods: methods that read specific + /// protocol message constructs and field types (e.g. ReadTag and + /// ReadInt32) and methods that read low-level values (e.g. + /// ReadRawVarint32 and ReadRawBytes). If you are reading encoded protocol + /// messages, you should use the former methods, but if you are reading some + /// other format of your own design, use the latter. The names of the former + /// methods are taken from the protocol buffer type names, not .NET types. + /// (Hence ReadFloat instead of ReadSingle, and ReadBool instead of ReadBoolean.) + /// + /// TODO(jonskeet): Consider whether recursion and size limits shouldn't be readonly, + /// set at construction time. + /// </remarks> + public sealed class CodedInputStream { + private readonly byte[] buffer; + private int bufferSize; + private int bufferSizeAfterLimit = 0; + private int bufferPos = 0; + private readonly Stream input; + private uint lastTag = 0; + + const int DefaultRecursionLimit = 64; + const int DefaultSizeLimit = 64 << 20; // 64MB + const int BufferSize = 4096; + + /// <summary> + /// The total number of bytes read before the current buffer. The + /// total bytes read up to the current position can be computed as + /// totalBytesRetired + bufferPos. + /// </summary> + private int totalBytesRetired = 0; + + /// <summary> + /// The absolute position of the end of the current message. + /// </summary> + private int currentLimit = int.MaxValue; + + /// <summary> + /// <see cref="SetRecursionLimit"/> + /// </summary> + private int recursionDepth = 0; + private int recursionLimit = DefaultRecursionLimit; + + /// <summary> + /// <see cref="SetSizeLimit"/> + /// </summary> + private int sizeLimit = DefaultSizeLimit; + + #region Construction + /// <summary> + /// Creates a new CodedInputStream reading data from the given + /// stream. + /// </summary> + public static CodedInputStream CreateInstance(Stream input) { + return new CodedInputStream(input); + } + + /// <summary> + /// Creates a new CodedInputStream reading data from the given + /// byte array. + /// </summary> + public static CodedInputStream CreateInstance(byte[] buf) { + return new CodedInputStream(buf); + } + + private CodedInputStream(byte[] buffer) { + this.buffer = buffer; + this.bufferSize = buffer.Length; + this.input = null; + } + + private CodedInputStream(Stream input) { + this.buffer = new byte[BufferSize]; + this.bufferSize = 0; + this.input = input; + } + #endregion + + #region Validation + /// <summary> + /// Verifies that the last call to ReadTag() returned the given tag value. + /// This is used to verify that a nested group ended with the correct + /// end tag. + /// </summary> + /// <exception cref="InvalidProtocolBufferException">The last + /// tag read was not the one specified</exception> + public void CheckLastTagWas(uint value) { + if (lastTag != value) { + throw InvalidProtocolBufferException.InvalidEndTag(); + } + } + #endregion + + #region Reading of tags etc + /// <summary> + /// Attempt to read a field tag, returning 0 if we have reached the end + /// of the input data. Protocol message parsers use this to read tags, + /// since a protocol message may legally end wherever a tag occurs, and + /// zero is not a valid tag number. + /// </summary> + public uint ReadTag() { + if (bufferPos == bufferSize && !RefillBuffer(false)) { + lastTag = 0; + return 0; + } + + lastTag = ReadRawVarint32(); + if (lastTag == 0) { + // If we actually read zero, that's not a valid tag. + throw InvalidProtocolBufferException.InvalidTag(); + } + return lastTag; + } + + /// <summary> + /// Read a double field from the stream. + /// </summary> + public double ReadDouble() { + // TODO(jonskeet): Test this on different endiannesses + return BitConverter.Int64BitsToDouble((long) ReadRawLittleEndian64()); + } + + /// <summary> + /// Read a float field from the stream. + /// </summary> + public float ReadFloat() { + // TODO(jonskeet): Test this on different endiannesses + uint raw = ReadRawLittleEndian32(); + byte[] rawBytes = BitConverter.GetBytes(raw); + return BitConverter.ToSingle(rawBytes, 0); + } + + /// <summary> + /// Read a uint64 field from the stream. + /// </summary> + public ulong ReadUInt64() { + return ReadRawVarint64(); + } + + /// <summary> + /// Read an int64 field from the stream. + /// </summary> + public long ReadInt64() { + return (long) ReadRawVarint64(); + } + + /// <summary> + /// Read an int32 field from the stream. + /// </summary> + public int ReadInt32() { + return (int) ReadRawVarint32(); + } + + /// <summary> + /// Read a fixed64 field from the stream. + /// </summary> + public ulong ReadFixed64() { + return ReadRawLittleEndian64(); + } + + /// <summary> + /// Read a fixed32 field from the stream. + /// </summary> + public uint ReadFixed32() { + return ReadRawLittleEndian32(); + } + + /// <summary> + /// Read a bool field from the stream. + /// </summary> + public bool ReadBool() { + return ReadRawVarint32() != 0; + } + + /// <summary> + /// Reads a string field from the stream. + /// </summary> + public String ReadString() { + int size = (int) ReadRawVarint32(); + if (size < bufferSize - bufferPos && size > 0) { + // Fast path: We already have the bytes in a contiguous buffer, so + // just copy directly from it. + String result = Encoding.UTF8.GetString(buffer, bufferPos, size); + bufferPos += size; + return result; + } else { + // Slow path: Build a byte array first then copy it. + return Encoding.UTF8.GetString(ReadRawBytes(size)); + } + } + + /// <summary> + /// Reads a group field value from the stream. + /// </summary> + public void ReadGroup(int fieldNumber, IBuilder builder, + ExtensionRegistry extensionRegistry) { + if (recursionDepth >= recursionLimit) { + throw InvalidProtocolBufferException.RecursionLimitExceeded(); + } + ++recursionDepth; + builder.WeakMergeFrom(this, extensionRegistry); + CheckLastTagWas(WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup)); + --recursionDepth; + } + + /// <summary> + /// Reads a group field value from the stream and merges it into the given + /// UnknownFieldSet. + /// </summary> + public void ReadUnknownGroup(int fieldNumber, UnknownFieldSet.Builder builder) { + if (recursionDepth >= recursionLimit) { + throw InvalidProtocolBufferException.RecursionLimitExceeded(); + } + ++recursionDepth; + builder.MergeFrom(this); + CheckLastTagWas(WireFormat.MakeTag(fieldNumber, WireFormat.WireType.EndGroup)); + --recursionDepth; + } + + /// <summary> + /// Reads an embedded message field value from the stream. + /// </summary> + public void ReadMessage(IBuilder builder, ExtensionRegistry extensionRegistry) { + int length = (int) ReadRawVarint32(); + if (recursionDepth >= recursionLimit) { + throw InvalidProtocolBufferException.RecursionLimitExceeded(); + } + int oldLimit = PushLimit(length); + ++recursionDepth; + builder.WeakMergeFrom(this, extensionRegistry); + CheckLastTagWas(0); + --recursionDepth; + PopLimit(oldLimit); + } + + /// <summary> + /// Reads a bytes field value from the stream. + /// </summary> + public ByteString ReadBytes() { + int size = (int) ReadRawVarint32(); + if (size < bufferSize - bufferPos && size > 0) { + // Fast path: We already have the bytes in a contiguous buffer, so + // just copy directly from it. + ByteString result = ByteString.CopyFrom(buffer, bufferPos, size); + bufferPos += size; + return result; + } else { + // Slow path: Build a byte array first then copy it. + return ByteString.CopyFrom(ReadRawBytes(size)); + } + } + + /// <summary> + /// Reads a uint32 field value from the stream. + /// </summary> + public uint ReadUInt32() { + return ReadRawVarint32(); + } + + /// <summary> + /// Reads an enum field value from the stream. The caller is responsible + /// for converting the numeric value to an actual enum. + /// </summary> + public int ReadEnum() { + return (int) ReadRawVarint32(); + } + + /// <summary> + /// Reads an sfixed32 field value from the stream. + /// </summary> + public int ReadSFixed32() { + return (int) ReadRawLittleEndian32(); + } + + /// <summary> + /// Reads an sfixed64 field value from the stream. + /// </summary> + public long ReadSFixed64() { + return (long) ReadRawLittleEndian64(); + } + + /// <summary> + /// Reads an sint32 field value from the stream. + /// </summary> + public int ReadSInt32() { + return DecodeZigZag32(ReadRawVarint32()); + } + + /// <summary> + /// Reads an sint64 field value from the stream. + /// </summary> + public long ReadSInt64() { + return DecodeZigZag64(ReadRawVarint64()); + } + + /// <summary> + /// Reads a field of any primitive type. Enums, groups and embedded + /// messages are not handled by this method. + /// </summary> + public object ReadPrimitiveField(FieldType fieldType) { + switch (fieldType) { + case FieldType.Double: return ReadDouble(); + case FieldType.Float: return ReadFloat(); + case FieldType.Int64: return ReadInt64(); + case FieldType.UInt64: return ReadUInt64(); + case FieldType.Int32: return ReadInt32(); + case FieldType.Fixed64: return ReadFixed64(); + case FieldType.Fixed32: return ReadFixed32(); + case FieldType.Bool: return ReadBool(); + case FieldType.String: return ReadString(); + case FieldType.Bytes: return ReadBytes(); + case FieldType.UInt32: return ReadUInt32(); + case FieldType.SFixed32: return ReadSFixed32(); + case FieldType.SFixed64: return ReadSFixed64(); + case FieldType.SInt32: return ReadSInt32(); + case FieldType.SInt64: return ReadSInt64(); + case FieldType.Group: + throw new ArgumentException("ReadPrimitiveField() cannot handle nested groups."); + case FieldType.Message: + throw new ArgumentException("ReadPrimitiveField() cannot handle embedded messages."); + // We don't handle enums because we don't know what to do if the + // value is not recognized. + case FieldType.Enum: + throw new ArgumentException("ReadPrimitiveField() cannot handle enums."); + default: + throw new ArgumentOutOfRangeException("Invalid field type " + fieldType); + } + } + + #endregion + + #region Underlying reading primitives + + /// <summary> + /// Same code as ReadRawVarint32, but read each byte individually, checking for + /// buffer overflow. + /// </summary> + private uint SlowReadRawVarint32() { + int tmp = ReadRawByte(); + if (tmp < 128) { + return (uint)tmp; + } + int result = tmp & 0x7f; + if ((tmp = ReadRawByte()) < 128) { + result |= tmp << 7; + } else { + result |= (tmp & 0x7f) << 7; + if ((tmp = ReadRawByte()) < 128) { + result |= tmp << 14; + } else { + result |= (tmp & 0x7f) << 14; + if ((tmp = ReadRawByte()) < 128) { + result |= tmp << 21; + } else { + result |= (tmp & 0x7f) << 21; + result |= (tmp = ReadRawByte()) << 28; + if (tmp >= 128) { + // Discard upper 32 bits. + for (int i = 0; i < 5; i++) { + if (ReadRawByte() < 128) return (uint)result; + } + throw InvalidProtocolBufferException.MalformedVarint(); + } + } + } + } + return (uint)result; + } + + /// <summary> + /// Read a raw Varint from the stream. If larger than 32 bits, discard the upper bits. + /// This method is optimised for the case where we've got lots of data in the buffer. + /// That means we can check the size just once, then just read directly from the buffer + /// without constant rechecking of the buffer length. + /// </summary> + public uint ReadRawVarint32() { + if (bufferPos + 5 > bufferSize) { + return SlowReadRawVarint32(); + } + + int tmp = buffer[bufferPos++]; + if (tmp < 128) { + return (uint)tmp; + } + int result = tmp & 0x7f; + if ((tmp = buffer[bufferPos++]) < 128) { + result |= tmp << 7; + } else { + result |= (tmp & 0x7f) << 7; + if ((tmp = buffer[bufferPos++]) < 128) { + result |= tmp << 14; + } else { + result |= (tmp & 0x7f) << 14; + if ((tmp = buffer[bufferPos++]) < 128) { + result |= tmp << 21; + } else { + result |= (tmp & 0x7f) << 21; + result |= (tmp = buffer[bufferPos++]) << 28; + if (tmp >= 128) { + // Discard upper 32 bits. + // Note that this has to use ReadRawByte() as we only ensure we've + // got at least 5 bytes at the start of the method. This lets us + // use the fast path in more cases, and we rarely hit this section of code. + for (int i = 0; i < 5; i++) { + if (ReadRawByte() < 128) return (uint)result; + } + throw InvalidProtocolBufferException.MalformedVarint(); + } + } + } + } + return (uint)result; + } + + /// <summary> + /// Read a raw varint from the stream. + /// </summary> + public ulong ReadRawVarint64() { + int shift = 0; + ulong result = 0; + while (shift < 64) { + byte b = ReadRawByte(); + result |= (ulong)(b & 0x7F) << shift; + if ((b & 0x80) == 0) { + return result; + } + shift += 7; + } + throw InvalidProtocolBufferException.MalformedVarint(); + } + + /// <summary> + /// Read a 32-bit little-endian integer from the stream. + /// </summary> + public uint ReadRawLittleEndian32() { + uint b1 = ReadRawByte(); + uint b2 = ReadRawByte(); + uint b3 = ReadRawByte(); + uint b4 = ReadRawByte(); + return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24); + } + + /// <summary> + /// Read a 64-bit little-endian integer from the stream. + /// </summary> + public ulong ReadRawLittleEndian64() { + ulong b1 = ReadRawByte(); + ulong b2 = ReadRawByte(); + ulong b3 = ReadRawByte(); + ulong b4 = ReadRawByte(); + ulong b5 = ReadRawByte(); + ulong b6 = ReadRawByte(); + ulong b7 = ReadRawByte(); + ulong b8 = ReadRawByte(); + return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24) + | (b5 << 32) | (b6 << 40) | (b7 << 48) | (b8 << 56); + } + #endregion + + /// <summary> + /// Decode a 32-bit value with ZigZag encoding. + /// </summary> + /// <remarks> + /// ZigZag encodes signed integers into values that can be efficiently + /// encoded with varint. (Otherwise, negative values must be + /// sign-extended to 64 bits to be varint encoded, thus always taking + /// 10 bytes on the wire.) + /// </remarks> + public static int DecodeZigZag32(uint n) { + return (int)(n >> 1) ^ -(int)(n & 1); + } + + /// <summary> + /// Decode a 32-bit value with ZigZag encoding. + /// </summary> + /// <remarks> + /// ZigZag encodes signed integers into values that can be efficiently + /// encoded with varint. (Otherwise, negative values must be + /// sign-extended to 64 bits to be varint encoded, thus always taking + /// 10 bytes on the wire.) + /// </remarks> + public static long DecodeZigZag64(ulong n) { + return (long)(n >> 1) ^ -(long)(n & 1); + } + + /// <summary> + /// Set the maximum message recursion depth. + /// </summary> + /// <remarks> + /// In order to prevent malicious + /// messages from causing stack overflows, CodedInputStream limits + /// how deeply messages may be nested. The default limit is 64. + /// </remarks> + public int SetRecursionLimit(int limit) { + if (limit < 0) { + throw new ArgumentOutOfRangeException("Recursion limit cannot be negative: " + limit); + } + int oldLimit = recursionLimit; + recursionLimit = limit; + return oldLimit; + } + + /// <summary> + /// Set the maximum message size. + /// </summary> + /// <remarks> + /// In order to prevent malicious messages from exhausting memory or + /// causing integer overflows, CodedInputStream limits how large a message may be. + /// The default limit is 64MB. You should set this limit as small + /// as you can without harming your app's functionality. Note that + /// size limits only apply when reading from an InputStream, not + /// when constructed around a raw byte array (nor with ByteString.NewCodedInput). + /// </remarks> + public int SetSizeLimit(int limit) { + if (limit < 0) { + throw new ArgumentOutOfRangeException("Size limit cannot be negative: " + limit); + } + int oldLimit = sizeLimit; + sizeLimit = limit; + return oldLimit; + } + + #region Internal reading and buffer management + /// <summary> + /// Sets currentLimit to (current position) + byteLimit. This is called + /// when descending into a length-delimited embedded message. The previous + /// limit is returned. + /// </summary> + /// <returns>The old limit.</returns> + public int PushLimit(int byteLimit) { + if (byteLimit < 0) { + throw InvalidProtocolBufferException.NegativeSize(); + } + byteLimit += totalBytesRetired + bufferPos; + int oldLimit = currentLimit; + if (byteLimit > oldLimit) { + throw InvalidProtocolBufferException.TruncatedMessage(); + } + currentLimit = byteLimit; + + RecomputeBufferSizeAfterLimit(); + + return oldLimit; + } + + private void RecomputeBufferSizeAfterLimit() { + bufferSize += bufferSizeAfterLimit; + int bufferEnd = totalBytesRetired + bufferSize; + if (bufferEnd > currentLimit) { + // Limit is in current buffer. + bufferSizeAfterLimit = bufferEnd - currentLimit; + bufferSize -= bufferSizeAfterLimit; + } else { + bufferSizeAfterLimit = 0; + } + } + + /// <summary> + /// Discards the current limit, returning the previous limit. + /// </summary> + public void PopLimit(int oldLimit) { + currentLimit = oldLimit; + RecomputeBufferSizeAfterLimit(); + } + + /// <summary> + /// Called when buffer is empty to read more bytes from the + /// input. If <paramref name="mustSucceed"/> is true, RefillBuffer() gurantees that + /// either there will be at least one byte in the buffer when it returns + /// or it will throw an exception. If <paramref name="mustSucceed"/> is false, + /// RefillBuffer() returns false if no more bytes were available. + /// </summary> + /// <param name="mustSucceed"></param> + /// <returns></returns> + private bool RefillBuffer(bool mustSucceed) { + if (bufferPos < bufferSize) { + throw new InvalidOperationException("RefillBuffer() called when buffer wasn't empty."); + } + + if (totalBytesRetired + bufferSize == currentLimit) { + // Oops, we hit a limit. + if (mustSucceed) { + throw InvalidProtocolBufferException.TruncatedMessage(); + } else { + return false; + } + } + + totalBytesRetired += bufferSize; + + bufferPos = 0; + bufferSize = (input == null) ? 0 : input.Read(buffer, 0, buffer.Length); + if (bufferSize == 0) { + if (mustSucceed) { + throw InvalidProtocolBufferException.TruncatedMessage(); + } else { + return false; + } + } else { + RecomputeBufferSizeAfterLimit(); + int totalBytesRead = + totalBytesRetired + bufferSize + bufferSizeAfterLimit; + if (totalBytesRead > sizeLimit || totalBytesRead < 0) { + throw InvalidProtocolBufferException.SizeLimitExceeded(); + } + return true; + } + } + + /// <summary> + /// Read one byte from the input. + /// </summary> + /// <exception cref="InvalidProtocolBufferException"> + /// he end of the stream or the current limit was reached + /// </exception> + public byte ReadRawByte() { + if (bufferPos == bufferSize) { + RefillBuffer(true); + } + return buffer[bufferPos++]; + } + + /// <summary> + /// Read a fixed size of bytes from the input. + /// </summary> + /// <exception cref="InvalidProtocolBufferException"> + /// the end of the stream or the current limit was reached + /// </exception> + public byte[] ReadRawBytes(int size) { + if (size < 0) { + throw InvalidProtocolBufferException.NegativeSize(); + } + + if (totalBytesRetired + bufferPos + size > currentLimit) { + // Read to the end of the stream anyway. + SkipRawBytes(currentLimit - totalBytesRetired - bufferPos); + // Then fail. + throw InvalidProtocolBufferException.TruncatedMessage(); + } + + if (size <= bufferSize - bufferPos) { + // We have all the bytes we need already. + byte[] bytes = new byte[size]; + Array.Copy(buffer, bufferPos, bytes, 0, size); + bufferPos += size; + return bytes; + } else if (size < BufferSize) { + // Reading more bytes than are in the buffer, but not an excessive number + // of bytes. We can safely allocate the resulting array ahead of time. + + // First copy what we have. + byte[] bytes = new byte[size]; + int pos = bufferSize - bufferPos; + Array.Copy(buffer, bufferPos, bytes, 0, pos); + bufferPos = bufferSize; + + // We want to use RefillBuffer() and then copy from the buffer into our + // byte array rather than reading directly into our byte array because + // the input may be unbuffered. + RefillBuffer(true); + + while (size - pos > bufferSize) { + Array.Copy(buffer, 0, bytes, pos, bufferSize); + pos += bufferSize; + bufferPos = bufferSize; + RefillBuffer(true); + } + + Array.Copy(buffer, 0, bytes, pos, size - pos); + bufferPos = size - pos; + + return bytes; + } else { + // The size is very large. For security reasons, we can't allocate the + // entire byte array yet. The size comes directly from the input, so a + // maliciously-crafted message could provide a bogus very large size in + // order to trick the app into allocating a lot of memory. We avoid this + // by allocating and reading only a small chunk at a time, so that the + // malicious message must actually *be* extremely large to cause + // problems. Meanwhile, we limit the allowed size of a message elsewhere. + + // Remember the buffer markers since we'll have to copy the bytes out of + // it later. + int originalBufferPos = bufferPos; + int originalBufferSize = bufferSize; + + // Mark the current buffer consumed. + totalBytesRetired += bufferSize; + bufferPos = 0; + bufferSize = 0; + + // Read all the rest of the bytes we need. + int sizeLeft = size - (originalBufferSize - originalBufferPos); + List<byte[]> chunks = new List<byte[]>(); + + while (sizeLeft > 0) { + byte[] chunk = new byte[Math.Min(sizeLeft, BufferSize)]; + int pos = 0; + while (pos < chunk.Length) { + int n = (input == null) ? -1 : input.Read(chunk, pos, chunk.Length - pos); + if (n <= 0) { + throw InvalidProtocolBufferException.TruncatedMessage(); + } + totalBytesRetired += n; + pos += n; + } + sizeLeft -= chunk.Length; + chunks.Add(chunk); + } + + // OK, got everything. Now concatenate it all into one buffer. + byte[] bytes = new byte[size]; + + // Start by copying the leftover bytes from this.buffer. + int newPos = originalBufferSize - originalBufferPos; + Array.Copy(buffer, originalBufferPos, bytes, 0, newPos); + + // And now all the chunks. + foreach (byte[] chunk in chunks) { + Array.Copy(chunk, 0, bytes, newPos, chunk.Length); + newPos += chunk.Length; + } + + // Done. + return bytes; + } + } + + /// <summary> + /// Reads and discards a single field, given its tag value. + /// </summary> + /// <returns>false if the tag is an end-group tag, in which case + /// nothing is skipped. Otherwise, returns true.</returns> + public bool SkipField(uint tag) { + switch (WireFormat.GetTagWireType(tag)) { + case WireFormat.WireType.Varint: + ReadInt32(); + return true; + case WireFormat.WireType.Fixed64: + ReadRawLittleEndian64(); + return true; + case WireFormat.WireType.LengthDelimited: + SkipRawBytes((int) ReadRawVarint32()); + return true; + case WireFormat.WireType.StartGroup: + SkipMessage(); + CheckLastTagWas( + WireFormat.MakeTag(WireFormat.GetTagFieldNumber(tag), + WireFormat.WireType.EndGroup)); + return true; + case WireFormat.WireType.EndGroup: + return false; + case WireFormat.WireType.Fixed32: + ReadRawLittleEndian32(); + return true; + default: + throw InvalidProtocolBufferException.InvalidWireType(); + } + } + + /// <summary> + /// Reads and discards an entire message. This will read either until EOF + /// or until an endgroup tag, whichever comes first. + /// </summary> + public void SkipMessage() { + while (true) { + uint tag = ReadTag(); + if (tag == 0 || !SkipField(tag)) { + return; + } + } + } + + /// <summary> + /// Reads and discards <paramref name="size"/> bytes. + /// </summary> + /// <exception cref="InvalidProtocolBufferException">the end of the stream + /// or the current limit was reached</exception> + public void SkipRawBytes(int size) { + if (size < 0) { + throw InvalidProtocolBufferException.NegativeSize(); + } + + if (totalBytesRetired + bufferPos + size > currentLimit) { + // Read to the end of the stream anyway. + SkipRawBytes(currentLimit - totalBytesRetired - bufferPos); + // Then fail. + throw InvalidProtocolBufferException.TruncatedMessage(); + } + + if (size < bufferSize - bufferPos) { + // We have all the bytes we need already. + bufferPos += size; + } else { + // Skipping more bytes than are in the buffer. First skip what we have. + int pos = bufferSize - bufferPos; + totalBytesRetired += pos; + bufferPos = 0; + bufferSize = 0; + + // Then skip directly from the InputStream for the rest. + if (pos < size) { + // TODO(jonskeet): Java implementation uses skip(). Not sure whether this is really equivalent... + if (input == null) { + throw InvalidProtocolBufferException.TruncatedMessage(); + } + input.Seek(size - pos, SeekOrigin.Current); + if (input.Position > input.Length) { + throw InvalidProtocolBufferException.TruncatedMessage(); + } + totalBytesRetired += size - pos; + } + } + } + #endregion + } +} diff --git a/src/ProtocolBuffers/CodedOutputStream.cs b/src/ProtocolBuffers/CodedOutputStream.cs new file mode 100644 index 00000000..0abfa39a --- /dev/null +++ b/src/ProtocolBuffers/CodedOutputStream.cs @@ -0,0 +1,765 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.IO; +using System.Text; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// Encodes and writes protocol message fields. + /// </summary> + /// <remarks> + /// This class contains two kinds of methods: methods that write specific + /// protocol message constructs and field types (e.g. WriteTag and + /// WriteInt32) and methods that write low-level values (e.g. + /// WriteRawVarint32 and WriteRawBytes). If you are writing encoded protocol + /// messages, you should use the former methods, but if you are writing some + /// other format of your own design, use the latter. The names of the former + /// methods are taken from the protocol buffer type names, not .NET types. + /// (Hence WriteFloat instead of WriteSingle, and WriteBool instead of WriteBoolean.) + /// </remarks> + public sealed class CodedOutputStream { + /// <summary> + /// The buffer size used by CreateInstance(Stream). + /// </summary> + public static readonly int DefaultBufferSize = 4096; + + private readonly byte[] buffer; + private readonly int limit; + private int position; + private readonly Stream output; + + #region Construction + private CodedOutputStream(byte[] buffer, int offset, int length) { + this.output = null; + this.buffer = buffer; + this.position = offset; + this.limit = offset + length; + } + + private CodedOutputStream(Stream output, byte[] buffer) { + this.output = output; + this.buffer = buffer; + this.position = 0; + this.limit = buffer.Length; + } + + /// <summary> + /// Creates a new CodedOutputStream which write to the given stream. + /// </summary> + public static CodedOutputStream CreateInstance(Stream output) { + return CreateInstance(output, DefaultBufferSize); + } + + /// <summary> + /// Creates a new CodedOutputStream which write to the given stream and uses + /// the specified buffer size. + /// </summary> + public static CodedOutputStream CreateInstance(Stream output, int bufferSize) { + return new CodedOutputStream(output, new byte[bufferSize]); + } + + /// <summary> + /// Creates a new CodedOutputStream that writes directly to the given + /// byte array. If more bytes are written than fit in the array, + /// OutOfSpaceException will be thrown. + /// </summary> + public static CodedOutputStream CreateInstance(byte[] flatArray) { + return CreateInstance(flatArray, 0, flatArray.Length); + } + + /// <summary> + /// Creates a new CodedOutputStream that writes directly to the given + /// byte array slice. If more bytes are written than fit in the array, + /// OutOfSpaceException will be thrown. + /// </summary> + public static CodedOutputStream CreateInstance(byte[] flatArray, int offset, int length) { + return new CodedOutputStream(flatArray, offset, length); + } + #endregion + + #region Writing of tags etc + /// <summary> + /// Writes a double field value, including tag, to the stream. + /// </summary> + public void WriteDouble(int fieldNumber, double value) { + // TODO(jonskeet): Test this on different endiannesses + WriteTag(fieldNumber, WireFormat.WireType.Fixed64); + WriteRawLittleEndian64((ulong)BitConverter.DoubleToInt64Bits(value)); + } + + /// <summary> + /// Writes a float field value, including tag, to the stream. + /// </summary> + public void WriteFloat(int fieldNumber, float value) { + WriteTag(fieldNumber, WireFormat.WireType.Fixed32); + // TODO(jonskeet): Test this on different endiannesses + byte[] rawBytes = BitConverter.GetBytes(value); + uint asInteger = BitConverter.ToUInt32(rawBytes, 0); + WriteRawLittleEndian32(asInteger); + } + + /// <summary> + /// Writes a uint64 field value, including tag, to the stream. + /// </summary> + public void WriteUInt64(int fieldNumber, ulong value) { + WriteTag(fieldNumber, WireFormat.WireType.Varint); + WriteRawVarint64(value); + } + + /// <summary> + /// Writes an int64 field value, including tag, to the stream. + /// </summary> + public void WriteInt64(int fieldNumber, long value) { + WriteTag(fieldNumber, WireFormat.WireType.Varint); + WriteRawVarint64((ulong)value); + } + + /// <summary> + /// Writes an int32 field value, including tag, to the stream. + /// </summary> + public void WriteInt32(int fieldNumber, int value) { + WriteTag(fieldNumber, WireFormat.WireType.Varint); + if (value >= 0) { + WriteRawVarint32((uint)value); + } else { + // Must sign-extend. + WriteRawVarint64((ulong)value); + } + } + + /// <summary> + /// Writes a fixed64 field value, including tag, to the stream. + /// </summary> + public void WriteFixed64(int fieldNumber, ulong value) { + WriteTag(fieldNumber, WireFormat.WireType.Fixed64); + WriteRawLittleEndian64(value); + } + + /// <summary> + /// Writes a fixed32 field value, including tag, to the stream. + /// </summary> + public void WriteFixed32(int fieldNumber, uint value) { + WriteTag(fieldNumber, WireFormat.WireType.Fixed32); + WriteRawLittleEndian32(value); + } + + /// <summary> + /// Writes a bool field value, including tag, to the stream. + /// </summary> + public void WriteBool(int fieldNumber, bool value) { + WriteTag(fieldNumber, WireFormat.WireType.Varint); + WriteRawByte(value ? (byte)1 : (byte)0); + } + + /// <summary> + /// Writes a string field value, including tag, to the stream. + /// </summary> + public void WriteString(int fieldNumber, string value) { + WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); + // Optimise the case where we have enough space to write + // the string directly to the buffer, which should be common. + int length = Encoding.UTF8.GetByteCount(value); + WriteRawVarint32((uint) length); + if (limit - position >= length) { + Encoding.UTF8.GetBytes(value, 0, value.Length, buffer, position); + position += length; + } else { + byte[] bytes = Encoding.UTF8.GetBytes(value); + WriteRawBytes(bytes); + } + } + + /// <summary> + /// Writes a group field value, including tag, to the stream. + /// </summary> + public void WriteGroup(int fieldNumber, IMessage value) { + WriteTag(fieldNumber, WireFormat.WireType.StartGroup); + value.WriteTo(this); + WriteTag(fieldNumber, WireFormat.WireType.EndGroup); + } + + public void WriteUnknownGroup(int fieldNumber, UnknownFieldSet value) { + WriteTag(fieldNumber, WireFormat.WireType.StartGroup); + value.WriteTo(this); + WriteTag(fieldNumber, WireFormat.WireType.EndGroup); + } + + public void WriteMessage(int fieldNumber, IMessage value) { + WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); + WriteRawVarint32((uint)value.SerializedSize); + value.WriteTo(this); + } + + public void WriteBytes(int fieldNumber, ByteString value) { + // TODO(jonskeet): Optimise this! (No need to copy the bytes twice.) + WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); + byte[] bytes = value.ToByteArray(); + WriteRawVarint32((uint)bytes.Length); + WriteRawBytes(bytes); + } + + public void WriteUInt32(int fieldNumber, uint value) { + WriteTag(fieldNumber, WireFormat.WireType.Varint); + WriteRawVarint32(value); + } + + public void WriteEnum(int fieldNumber, int value) { + WriteTag(fieldNumber, WireFormat.WireType.Varint); + WriteRawVarint32((uint)value); + } + + public void WriteSFixed32(int fieldNumber, int value) { + WriteTag(fieldNumber, WireFormat.WireType.Fixed32); + WriteRawLittleEndian32((uint)value); + } + + public void WriteSFixed64(int fieldNumber, long value) { + WriteTag(fieldNumber, WireFormat.WireType.Fixed64); + WriteRawLittleEndian64((ulong)value); + } + + public void WriteSInt32(int fieldNumber, int value) { + WriteTag(fieldNumber, WireFormat.WireType.Varint); + WriteRawVarint32(EncodeZigZag32(value)); + } + + public void WriteSInt64(int fieldNumber, long value) { + WriteTag(fieldNumber, WireFormat.WireType.Varint); + WriteRawVarint64(EncodeZigZag64(value)); + } + + public void WriteMessageSetExtension(int fieldNumber, IMessage value) { + WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.StartGroup); + WriteUInt32(WireFormat.MessageSetField.TypeID, (uint)fieldNumber); + WriteMessage(WireFormat.MessageSetField.Message, value); + WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.EndGroup); + } + + public void WriteRawMessageSetExtension(int fieldNumber, ByteString value) { + WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.StartGroup); + WriteUInt32(WireFormat.MessageSetField.TypeID, (uint)fieldNumber); + WriteBytes(WireFormat.MessageSetField.Message, value); + WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.EndGroup); + } + + public void WriteField(FieldType fieldType, int fieldNumber, object value) { + switch (fieldType) { + case FieldType.Double: WriteDouble(fieldNumber, (double)value); break; + case FieldType.Float: WriteFloat(fieldNumber, (float)value); break; + case FieldType.Int64: WriteInt64(fieldNumber, (long)value); break; + case FieldType.UInt64: WriteUInt64(fieldNumber, (ulong)value); break; + case FieldType.Int32: WriteInt32(fieldNumber, (int)value); break; + case FieldType.Fixed64: WriteFixed64(fieldNumber, (ulong)value); break; + case FieldType.Fixed32: WriteFixed32(fieldNumber, (uint)value); break; + case FieldType.Bool: WriteBool(fieldNumber, (bool)value); break; + case FieldType.String: WriteString(fieldNumber, (string)value); break; + case FieldType.Group: WriteGroup(fieldNumber, (IMessage)value); break; + case FieldType.Message: WriteMessage(fieldNumber, (IMessage)value); break; + case FieldType.Bytes: WriteBytes(fieldNumber, (ByteString)value); break; + case FieldType.UInt32: WriteUInt32(fieldNumber, (uint)value); break; + case FieldType.SFixed32: WriteSFixed32(fieldNumber, (int)value); break; + case FieldType.SFixed64: WriteSFixed64(fieldNumber, (long)value); break; + case FieldType.SInt32: WriteSInt32(fieldNumber, (int)value); break; + case FieldType.SInt64: WriteSInt64(fieldNumber, (long)value); break; + case FieldType.Enum: WriteEnum(fieldNumber, ((EnumValueDescriptor)value).Number); + break; + } + } + + #endregion + + #region Underlying writing primitives + /// <summary> + /// Encodes and writes a tag. + /// </summary> + public void WriteTag(int fieldNumber, WireFormat.WireType type) { + WriteRawVarint32(WireFormat.MakeTag(fieldNumber, type)); + } + + private void SlowWriteRawVarint32(uint value) { + while (true) { + if ((value & ~0x7F) == 0) { + WriteRawByte(value); + return; + } else { + WriteRawByte((value & 0x7F) | 0x80); + value >>= 7; + } + } + } + + /// <summary> + /// Writes a 32 bit value as a varint. The fast route is taken when + /// there's enough buffer space left to whizz through without checking + /// for each byte; otherwise, we resort to calling WriteRawByte each time. + /// </summary> + public void WriteRawVarint32(uint value) { + if (position + 5 > limit) { + SlowWriteRawVarint32(value); + return; + } + + while (true) { + if ((value & ~0x7F) == 0) { + buffer[position++] = (byte) value; + return; + } else { + buffer[position++] = (byte)((value & 0x7F) | 0x80); + value >>= 7; + } + } + } + + public void WriteRawVarint64(ulong value) { + while (true) { + if ((value & ~0x7FUL) == 0) { + WriteRawByte((uint)value); + return; + } else { + WriteRawByte(((uint)value & 0x7F) | 0x80); + value >>= 7; + } + } + } + + public void WriteRawLittleEndian32(uint value) { + WriteRawByte((byte)value); + WriteRawByte((byte)(value >> 8)); + WriteRawByte((byte)(value >> 16)); + WriteRawByte((byte)(value >> 24)); + } + + public void WriteRawLittleEndian64(ulong value) { + WriteRawByte((byte)value); + WriteRawByte((byte)(value >> 8)); + WriteRawByte((byte)(value >> 16)); + WriteRawByte((byte)(value >> 24)); + WriteRawByte((byte)(value >> 32)); + WriteRawByte((byte)(value >> 40)); + WriteRawByte((byte)(value >> 48)); + WriteRawByte((byte)(value >> 56)); + } + + public void WriteRawByte(byte value) { + if (position == limit) { + RefreshBuffer(); + } + + buffer[position++] = value; + } + + public void WriteRawByte(uint value) { + WriteRawByte((byte)value); + } + + /// <summary> + /// Writes out an array of bytes. + /// </summary> + public void WriteRawBytes(byte[] value) { + WriteRawBytes(value, 0, value.Length); + } + + /// <summary> + /// Writes out part of an array of bytes. + /// </summary> + public void WriteRawBytes(byte[] value, int offset, int length) { + if (limit - position >= length) { + Array.Copy(value, offset, buffer, position, length); + // We have room in the current buffer. + position += length; + } else { + // Write extends past current buffer. Fill the rest of this buffer and + // flush. + int bytesWritten = limit - position; + Array.Copy(value, offset, buffer, position, bytesWritten); + offset += bytesWritten; + length -= bytesWritten; + position = limit; + RefreshBuffer(); + + // Now deal with the rest. + // Since we have an output stream, this is our buffer + // and buffer offset == 0 + if (length <= limit) { + // Fits in new buffer. + Array.Copy(value, offset, buffer, 0, length); + position = length; + } else { + // Write is very big. Let's do it all at once. + output.Write(value, offset, length); + } + } + } + #endregion + + #region Size computations + + const int LittleEndian64Size = 8; + const int LittleEndian32Size = 4; + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// double field, including the tag. + /// </summary> + public static int ComputeDoubleSize(int fieldNumber, double value) { + return ComputeTagSize(fieldNumber) + LittleEndian64Size; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// float field, including the tag. + /// </summary> + public static int ComputeFloatSize(int fieldNumber, float value) { + return ComputeTagSize(fieldNumber) + LittleEndian32Size; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// uint64 field, including the tag. + /// </summary> + public static int ComputeUInt64Size(int fieldNumber, ulong value) { + return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size(value); + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode an + /// int64 field, including the tag. + /// </summary> + public static int ComputeInt64Size(int fieldNumber, long value) { + return ComputeTagSize(fieldNumber) + ComputeRawVarint64Size((ulong)value); + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode an + /// int32 field, including the tag. + /// </summary> + public static int ComputeInt32Size(int fieldNumber, int value) { + if (value >= 0) { + return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint)value); + } else { + // Must sign-extend. + return ComputeTagSize(fieldNumber) + 10; + } + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// fixed64 field, including the tag. + /// </summary> + public static int ComputeFixed64Size(int fieldNumber, ulong value) { + return ComputeTagSize(fieldNumber) + LittleEndian64Size; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// fixed32 field, including the tag. + /// </summary> + public static int ComputeFixed32Size(int fieldNumber, uint value) { + return ComputeTagSize(fieldNumber) + LittleEndian32Size; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// bool field, including the tag. + /// </summary> + public static int ComputeBoolSize(int fieldNumber, bool value) { + return ComputeTagSize(fieldNumber) + 1; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// string field, including the tag. + /// </summary> + public static int ComputeStringSize(int fieldNumber, String value) { + int byteArraySize = Encoding.UTF8.GetByteCount(value); + return ComputeTagSize(fieldNumber) + + ComputeRawVarint32Size((uint)byteArraySize) + + byteArraySize; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// group field, including the tag. + /// </summary> + public static int ComputeGroupSize(int fieldNumber, IMessage value) { + return ComputeTagSize(fieldNumber) * 2 + value.SerializedSize; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// group field represented by an UnknownFieldSet, including the tag. + /// </summary> + public static int ComputeUnknownGroupSize(int fieldNumber, + UnknownFieldSet value) { + return ComputeTagSize(fieldNumber) * 2 + value.SerializedSize; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode an + /// embedded message field, including the tag. + /// </summary> + public static int ComputeMessageSize(int fieldNumber, IMessage value) { + int size = value.SerializedSize; + return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint)size) + size; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// bytes field, including the tag. + /// </summary> + public static int ComputeBytesSize(int fieldNumber, ByteString value) { + return ComputeTagSize(fieldNumber) + + ComputeRawVarint32Size((uint)value.Length) + + value.Length; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// uint32 field, including the tag. + /// </summary> + public static int ComputeUInt32Size(int fieldNumber, uint value) { + return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size(value); + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// enum field, including the tag. The caller is responsible for + /// converting the enum value to its numeric value. + /// </summary> + public static int ComputeEnumSize(int fieldNumber, int value) { + return ComputeTagSize(fieldNumber) + ComputeRawVarint32Size((uint)value); + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode an + /// sfixed32 field, including the tag. + /// </summary> + public static int ComputeSFixed32Size(int fieldNumber, int value) { + return ComputeTagSize(fieldNumber) + LittleEndian32Size; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode an + /// sfixed64 field, including the tag. + /// </summary> + public static int ComputeSFixed64Size(int fieldNumber, long value) { + return ComputeTagSize(fieldNumber) + LittleEndian64Size; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode an + /// sint32 field, including the tag. + /// </summary> + public static int ComputeSInt32Size(int fieldNumber, int value) { + return ComputeTagSize(fieldNumber) + + ComputeRawVarint32Size(EncodeZigZag32(value)); + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode an + /// sint64 field, including the tag. + /// </summary> + public static int ComputeSInt64Size(int fieldNumber, long value) { + return ComputeTagSize(fieldNumber) + + ComputeRawVarint64Size(EncodeZigZag64(value)); + } + + /* + * Compute the number of bytes that would be needed to encode a + * MessageSet extension to the stream. For historical reasons, + * the wire format differs from normal fields. + */ + /// <summary> + /// Compute the number of bytes that would be needed to encode a + /// MessageSet extension to the stream. For historical reasons, + /// the wire format differs from normal fields. + /// </summary> + public static int ComputeMessageSetExtensionSize(int fieldNumber, IMessage value) { + return ComputeTagSize(WireFormat.MessageSetField.Item) * 2 + + ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) + + ComputeMessageSize(WireFormat.MessageSetField.Message, value); + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode an + /// unparsed MessageSet extension field to the stream. For + /// historical reasons, the wire format differs from normal fields. + /// </summary> + public static int ComputeRawMessageSetExtensionSize(int fieldNumber, ByteString value) { + return ComputeTagSize(WireFormat.MessageSetField.Item) * 2 + + ComputeUInt32Size(WireFormat.MessageSetField.TypeID, (uint) fieldNumber) + + ComputeBytesSize(WireFormat.MessageSetField.Message, value); + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a varint. + /// </summary> + public static int ComputeRawVarint32Size(uint value) { + if ((value & (0xffffffff << 7)) == 0) return 1; + if ((value & (0xffffffff << 14)) == 0) return 2; + if ((value & (0xffffffff << 21)) == 0) return 3; + if ((value & (0xffffffff << 28)) == 0) return 4; + return 5; + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a varint. + /// </summary> + public static int ComputeRawVarint64Size(ulong value) { + if ((value & (0xffffffffffffffffL << 7)) == 0) return 1; + if ((value & (0xffffffffffffffffL << 14)) == 0) return 2; + if ((value & (0xffffffffffffffffL << 21)) == 0) return 3; + if ((value & (0xffffffffffffffffL << 28)) == 0) return 4; + if ((value & (0xffffffffffffffffL << 35)) == 0) return 5; + if ((value & (0xffffffffffffffffL << 42)) == 0) return 6; + if ((value & (0xffffffffffffffffL << 49)) == 0) return 7; + if ((value & (0xffffffffffffffffL << 56)) == 0) return 8; + if ((value & (0xffffffffffffffffL << 63)) == 0) return 9; + return 10; + } + + + /* + * Compute the number of bytes that would be needed to encode a + * field of arbitrary type, including tag, to the stream. + * + * @param type The field's type. + * @param number The field's number. + * @param value Object representing the field's value. Must be of the exact + * type which would be returned by + * {@link Message#getField(FieldDescriptor)} for + * this field. + */ + public static int ComputeFieldSize(FieldType fieldType, int fieldNumber, Object value) { + switch (fieldType) { + case FieldType.Double: return ComputeDoubleSize(fieldNumber, (double)value); + case FieldType.Float: return ComputeFloatSize(fieldNumber, (float)value); + case FieldType.Int64: return ComputeInt64Size(fieldNumber, (long)value); + case FieldType.UInt64: return ComputeUInt64Size(fieldNumber, (ulong)value); + case FieldType.Int32: return ComputeInt32Size(fieldNumber, (int)value); + case FieldType.Fixed64: return ComputeFixed64Size(fieldNumber, (ulong)value); + case FieldType.Fixed32: return ComputeFixed32Size(fieldNumber, (uint)value); + case FieldType.Bool: return ComputeBoolSize(fieldNumber, (bool)value); + case FieldType.String: return ComputeStringSize(fieldNumber, (string)value); + case FieldType.Group: return ComputeGroupSize(fieldNumber, (IMessage)value); + case FieldType.Message: return ComputeMessageSize(fieldNumber, (IMessage)value); + case FieldType.Bytes: return ComputeBytesSize(fieldNumber, (ByteString)value); + case FieldType.UInt32: return ComputeUInt32Size(fieldNumber, (uint)value); + case FieldType.SFixed32: return ComputeSFixed32Size(fieldNumber, (int)value); + case FieldType.SFixed64: return ComputeSFixed64Size(fieldNumber, (long)value); + case FieldType.SInt32: return ComputeSInt32Size(fieldNumber, (int)value); + case FieldType.SInt64: return ComputeSInt64Size(fieldNumber, (long)value); + case FieldType.Enum: return ComputeEnumSize(fieldNumber, ((EnumValueDescriptor)value).Number); + default: + throw new ArgumentOutOfRangeException("Invalid field type " + fieldType); + } + } + + /// <summary> + /// Compute the number of bytes that would be needed to encode a tag. + /// </summary> + public static int ComputeTagSize(int fieldNumber) { + return ComputeRawVarint32Size(WireFormat.MakeTag(fieldNumber, 0)); + } + #endregion + + /// <summary> + /// Encode a 32-bit value with ZigZag encoding. + /// </summary> + /// <remarks> + /// ZigZag encodes signed integers into values that can be efficiently + /// encoded with varint. (Otherwise, negative values must be + /// sign-extended to 64 bits to be varint encoded, thus always taking + /// 10 bytes on the wire.) + /// </remarks> + public static uint EncodeZigZag32(int n) { + // Note: the right-shift must be arithmetic + return (uint)((n << 1) ^ (n >> 31)); + } + + /// <summary> + /// Encode a 64-bit value with ZigZag encoding. + /// </summary> + /// <remarks> + /// ZigZag encodes signed integers into values that can be efficiently + /// encoded with varint. (Otherwise, negative values must be + /// sign-extended to 64 bits to be varint encoded, thus always taking + /// 10 bytes on the wire.) + /// </remarks> + public static ulong EncodeZigZag64(long n) { + return (ulong)((n << 1) ^ (n >> 63)); + } + + private void RefreshBuffer() { + if (output == null) { + // We're writing to a single buffer. + throw new OutOfSpaceException(); + } + + // Since we have an output stream, this is our buffer + // and buffer offset == 0 + output.Write(buffer, 0, position); + position = 0; + } + + /// <summary> + /// Indicates that a CodedOutputStream wrapping a flat byte array + /// ran out of space. + /// </summary> + public sealed class OutOfSpaceException : IOException { + internal OutOfSpaceException() + : base("CodedOutputStream was writing to a flat byte array and ran out of space.") { + } + } + + public void Flush() { + if (output != null) { + RefreshBuffer(); + } + } + + /// <summary> + /// Verifies that SpaceLeft returns zero. It's common to create a byte array + /// that is exactly big enough to hold a message, then write to it with + /// a CodedOutputStream. Calling CheckNoSpaceLeft after writing verifies that + /// the message was actually as big as expected, which can help bugs. + /// </summary> + public void CheckNoSpaceLeft() { + if (SpaceLeft != 0) { + throw new InvalidOperationException("Did not write as much data as expected."); + } + } + + /// <summary> + /// If writing to a flat array, returns the space left in the array. Otherwise, + /// throws an InvalidOperationException. + /// </summary> + public int SpaceLeft { + get { + if (output == null) { + return limit - position; + } else { + throw new InvalidOperationException( + "SpaceLeft can only be called on CodedOutputStreams that are " + + "writing to a flat array."); + } + } + } + } +}
\ No newline at end of file diff --git a/src/ProtocolBuffers/Collections/Dictionaries.cs b/src/ProtocolBuffers/Collections/Dictionaries.cs new file mode 100644 index 00000000..5ba02664 --- /dev/null +++ b/src/ProtocolBuffers/Collections/Dictionaries.cs @@ -0,0 +1,108 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Google.ProtocolBuffers.Collections { + + /// <summary> + /// Non-generic class with generic methods which proxy to the non-generic methods + /// in the generic class. + /// </summary> + public static class Dictionaries { + + /// <summary> + /// Compares two dictionaries for equality. Each value is compared with equality using Equals + /// for non-IEnumerable implementations, and using EnumerableEquals otherwise. + /// TODO(jonskeet): This is clearly pretty slow, and involves lots of boxing/unboxing... + /// </summary> + public static bool Equals<TKey, TValue>(IDictionary<TKey, TValue> left, IDictionary<TKey, TValue> right) { + if (left.Count != right.Count) { + return false; + } + foreach (KeyValuePair<TKey,TValue> leftEntry in left) + { + TValue rightValue; + if (!right.TryGetValue(leftEntry.Key, out rightValue)) { + return false; + } + + IEnumerable leftEnumerable = leftEntry.Value as IEnumerable; + IEnumerable rightEnumerable = rightValue as IEnumerable; + if (leftEnumerable == null || rightEnumerable == null) { + if (!object.Equals(leftEntry.Value, rightValue)) { + return false; + } + } else { + IEnumerator leftEnumerator = leftEnumerable.GetEnumerator(); + try { + foreach (object rightObject in rightEnumerable) { + if (!leftEnumerator.MoveNext()) { + return false; + } + if (!object.Equals(leftEnumerator.Current, rightObject)) { + return false; + } + } + if (leftEnumerator.MoveNext()) { + return false; + } + } finally { + if (leftEnumerator is IDisposable) { + ((IDisposable)leftEnumerator).Dispose(); + } + } + } + } + return true; + } + + public static IDictionary<TKey, TValue> AsReadOnly<TKey, TValue> (IDictionary<TKey, TValue> dictionary) { + return dictionary.IsReadOnly ? dictionary : new ReadOnlyDictionary<TKey, TValue>(dictionary); + } + + /// <summary> + /// Creates a hashcode for a dictionary by XORing the hashcodes of all the fields + /// and values. (By XORing, we avoid ordering issues.) + /// TODO(jonskeet): Currently XORs other stuff too, and assumes non-null values. + /// </summary> + public static int GetHashCode<TKey, TValue>(IDictionary<TKey, TValue> dictionary) { + int ret = 31; + foreach (KeyValuePair<TKey, TValue> entry in dictionary) { + int hash = entry.Key.GetHashCode() ^ GetDeepHashCode(entry.Value); + ret ^= hash; + } + return ret; + } + + /// <summary> + /// Determines the hash of a value by either taking it directly or hashing all the elements + /// for IEnumerable implementations. + /// </summary> + private static int GetDeepHashCode(object value) { + IEnumerable iterable = value as IEnumerable; + if (iterable == null) { + return value.GetHashCode(); + } + int hash = 29; + foreach (object element in iterable) { + hash = hash * 37 + element.GetHashCode(); + } + return hash; + } + } +} diff --git a/src/ProtocolBuffers/Collections/Lists.cs b/src/ProtocolBuffers/Collections/Lists.cs new file mode 100644 index 00000000..b1b6b122 --- /dev/null +++ b/src/ProtocolBuffers/Collections/Lists.cs @@ -0,0 +1,56 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections.Generic; +using System.Collections.ObjectModel; + +namespace Google.ProtocolBuffers.Collections { + + /// <summary> + /// Utility non-generic class for calling into Lists{T} using type inference. + /// </summary> + public static class Lists { + + /// <summary> + /// Returns a read-only view of the specified list. + /// </summary> + public static IList<T> AsReadOnly<T>(IList<T> list) { + return Lists<T>.AsReadOnly(list); + } + } + + /// <summary> + /// Utility class for dealing with lists. + /// </summary> + public static class Lists<T> { + + static readonly ReadOnlyCollection<T> empty = new ReadOnlyCollection<T>(new T[0]); + + /// <summary> + /// Returns an immutable empty list. + /// </summary> + public static ReadOnlyCollection<T> Empty { + get { return empty; } + } + + /// <summary> + /// Returns either the original reference if it's already read-only, + /// or a new ReadOnlyCollection wrapping the original list. + /// </summary> + public static IList<T> AsReadOnly(IList<T> list) { + return list.IsReadOnly ? list : new ReadOnlyCollection<T>(list); + } + } +} diff --git a/src/ProtocolBuffers/Collections/PopsicleList.cs b/src/ProtocolBuffers/Collections/PopsicleList.cs new file mode 100644 index 00000000..4efe13d0 --- /dev/null +++ b/src/ProtocolBuffers/Collections/PopsicleList.cs @@ -0,0 +1,95 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; + +namespace Google.ProtocolBuffers.Collections { + /// <summary> + /// Proxies calls to a <see cref="List{T}" />, but allows the list + /// to be made read-only (with the <see cref="MakeReadOnly" /> method), + /// after which any modifying methods throw <see cref="NotSupportedException" />. + /// </summary> + public sealed class PopsicleList<T> : IList<T> { + + private readonly List<T> items = new List<T>(); + private bool readOnly = false; + + /// <summary> + /// Makes this list read-only ("freezes the popsicle"). From this + /// point on, mutating methods (Clear, Add etc) will throw a + /// NotSupportedException. There is no way of "defrosting" the list afterwards. + /// </summary> + public void MakeReadOnly() { + readOnly = true; + } + + public int IndexOf(T item) { + return items.IndexOf(item); + } + + public void Insert(int index, T item) { + ValidateModification(); + items.Insert(index, item); + } + + public void RemoveAt(int index) { + ValidateModification(); + items.RemoveAt(index); + } + + public T this[int index] { + get { + return items[index]; + } + set { + ValidateModification(); + items[index] = value; + } + } + + public void Add(T item) { + ValidateModification(); + items.Add(item); + } + + public void Clear() { + ValidateModification(); + items.Clear(); + } + + public bool Contains(T item) { + return items.Contains(item); + } + + public void CopyTo(T[] array, int arrayIndex) { + items.CopyTo(array, arrayIndex); + } + + public int Count { + get { return items.Count; } + } + + public bool IsReadOnly { + get { return readOnly; } + } + + public bool Remove(T item) { + ValidateModification(); + return items.Remove(item); + } + + public IEnumerator<T> GetEnumerator() { + return items.GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() { + return GetEnumerator(); + } + + private void ValidateModification() { + if (readOnly) { + throw new NotSupportedException("List is read-only"); + } + } + } +} diff --git a/src/ProtocolBuffers/Collections/ReadOnlyDictionary.cs b/src/ProtocolBuffers/Collections/ReadOnlyDictionary.cs new file mode 100644 index 00000000..cd4b1898 --- /dev/null +++ b/src/ProtocolBuffers/Collections/ReadOnlyDictionary.cs @@ -0,0 +1,112 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Google.ProtocolBuffers.Collections { + /// <summary> + /// Read-only wrapper around another dictionary. + /// </summary> + public sealed class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue> { + readonly IDictionary<TKey, TValue> wrapped; + + public ReadOnlyDictionary(IDictionary<TKey, TValue> wrapped) { + this.wrapped = wrapped; + } + + public void Add(TKey key, TValue value) { + throw new InvalidOperationException(); + } + + public bool ContainsKey(TKey key) { + return wrapped.ContainsKey(key); + } + + public ICollection<TKey> Keys { + get { return wrapped.Keys; } + } + + public bool Remove(TKey key) { + throw new InvalidOperationException(); + } + + public bool TryGetValue(TKey key, out TValue value) { + return wrapped.TryGetValue(key, out value); + } + + public ICollection<TValue> Values { + get { return wrapped.Values; } + } + + public TValue this[TKey key] { + get { + return wrapped[key]; + } + set { + throw new InvalidOperationException(); + } + } + + public void Add(KeyValuePair<TKey, TValue> item) { + throw new InvalidOperationException(); + } + + public void Clear() { + throw new InvalidOperationException(); + } + + public bool Contains(KeyValuePair<TKey, TValue> item) { + return wrapped.Contains(item); + } + + public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) { + wrapped.CopyTo(array, arrayIndex); + } + + public int Count { + get { return wrapped.Count; } + } + + public bool IsReadOnly { + get { return true; } + } + + public bool Remove(KeyValuePair<TKey, TValue> item) { + throw new InvalidOperationException(); + } + + public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() { + return wrapped.GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() { + return ((IEnumerable) wrapped).GetEnumerator(); + } + + public override bool Equals(object obj) { + return wrapped.Equals(obj); + } + + public override int GetHashCode() { + return wrapped.GetHashCode(); + } + + public override string ToString() { + return wrapped.ToString(); + } + } +} diff --git a/src/ProtocolBuffers/Delegates.cs b/src/ProtocolBuffers/Delegates.cs new file mode 100644 index 00000000..08774019 --- /dev/null +++ b/src/ProtocolBuffers/Delegates.cs @@ -0,0 +1,32 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.IO; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Delegate to return a stream when asked, used by MessageStreamIterator. + /// </summary> + public delegate Stream StreamProvider(); + + // These delegate declarations mirror the ones in .NET 3.5 for the sake of familiarity. + internal delegate TResult Func<TResult>(); + internal delegate TResult Func<T, TResult>(T arg); + internal delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2); + internal delegate TResult Func<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3); + internal delegate TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4); + internal delegate void Action(); + internal delegate void Action<T1, T2>(T1 arg1, T2 arg2); +} diff --git a/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs b/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs new file mode 100644 index 00000000..14d6bb64 --- /dev/null +++ b/src/ProtocolBuffers/DescriptorProtos/CSharpOptions.cs @@ -0,0 +1,49 @@ +// 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 Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "CiRnb29nbGUvcHJvdG9idWYvY3NoYXJwX29wdGlvbnMucHJvdG8SD2dvb2ds" + + "ZS5wcm90b2J1ZhogZ29vZ2xlL3Byb3RvYnVmL2Rlc2NyaXB0b3IucHJvdG86" + + "NwoPQ1NoYXJwTmFtZXNwYWNlEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRp" + + "b25zGKCcASABKAk6PwoXQ1NoYXJwVW1icmVsbGFDbGFzc25hbWUSHC5nb29n" + + "bGUucHJvdG9idWYuRmlsZU9wdGlvbnMYoZwBIAEoCTo7ChNDU2hhcnBNdWx0" + + "aXBsZUZpbGVzEhwuZ29vZ2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKKcASAB" + + "KAg6OQoRQ1NoYXJwTmVzdENsYXNzZXMSHC5nb29nbGUucHJvdG9idWYuRmls" + + "ZU9wdGlvbnMYo5wBIAEoCDo7ChNDU2hhcnBQdWJsaWNDbGFzc2VzEhwuZ29v" + + "Z2xlLnByb3RvYnVmLkZpbGVPcHRpb25zGKScASABKAhCPILiCSdHb29nbGUu" + + "UHJvdG9jb2xCdWZmZXJzLkRlc2NyaXB0b3JQcm90b3OK4gkNQ1NoYXJwT3B0" + + "aW9ucw=="), + new pbd::FileDescriptor[] { + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.Descriptor, + }); + #endregion + + #region Extensions + public static readonly pb::GeneratedExtensionBase<string> CSharpNamespace = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[0]); + public static readonly pb::GeneratedExtensionBase<string> CSharpUmbrellaClassname = + pb::GeneratedSingleExtension<string>.CreateInstance(Descriptor.Extensions[1]); + public static readonly pb::GeneratedExtensionBase<bool> CSharpMultipleFiles = + pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[2]); + public static readonly pb::GeneratedExtensionBase<bool> CSharpNestClasses = + pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[3]); + public static readonly pb::GeneratedExtensionBase<bool> CSharpPublicClasses = + pb::GeneratedSingleExtension<bool>.CreateInstance(Descriptor.Extensions[4]); + #endregion + + #region Static variables + #endregion + } +} diff --git a/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs b/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs new file mode 100644 index 00000000..4e3c6572 --- /dev/null +++ b/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs @@ -0,0 +1,6131 @@ +// 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 DescriptorProtoFile { + + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom( + global::System.Convert.FromBase64String( + "CiBnb29nbGUvcHJvdG9idWYvZGVzY3JpcHRvci5wcm90bxIPZ29vZ2xlLnBy" + + "b3RvYnVmIkcKEUZpbGVEZXNjcmlwdG9yU2V0EjIKBGZpbGUYASADKAsyJC5n" + + "b29nbGUucHJvdG9idWYuRmlsZURlc2NyaXB0b3JQcm90byLcAgoTRmlsZURl" + + "c2NyaXB0b3JQcm90bxIMCgRuYW1lGAEgASgJEg8KB3BhY2thZ2UYAiABKAkS" + + "EgoKZGVwZW5kZW5jeRgDIAMoCRI2CgxtZXNzYWdlX3R5cGUYBCADKAsyIC5n" + + "b29nbGUucHJvdG9idWYuRGVzY3JpcHRvclByb3RvEjcKCWVudW1fdHlwZRgF" + + "IAMoCzIkLmdvb2dsZS5wcm90b2J1Zi5FbnVtRGVzY3JpcHRvclByb3RvEjgK" + + "B3NlcnZpY2UYBiADKAsyJy5nb29nbGUucHJvdG9idWYuU2VydmljZURlc2Ny" + + "aXB0b3JQcm90bxI4CglleHRlbnNpb24YByADKAsyJS5nb29nbGUucHJvdG9i" + + "dWYuRmllbGREZXNjcmlwdG9yUHJvdG8SLQoHb3B0aW9ucxgIIAEoCzIcLmdv" + + "b2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucyKpAwoPRGVzY3JpcHRvclByb3Rv" + + "EgwKBG5hbWUYASABKAkSNAoFZmllbGQYAiADKAsyJS5nb29nbGUucHJvdG9i" + + "dWYuRmllbGREZXNjcmlwdG9yUHJvdG8SOAoJZXh0ZW5zaW9uGAYgAygLMiUu" + + "Z29vZ2xlLnByb3RvYnVmLkZpZWxkRGVzY3JpcHRvclByb3RvEjUKC25lc3Rl" + + "ZF90eXBlGAMgAygLMiAuZ29vZ2xlLnByb3RvYnVmLkRlc2NyaXB0b3JQcm90" + + "bxI3CgllbnVtX3R5cGUYBCADKAsyJC5nb29nbGUucHJvdG9idWYuRW51bURl" + + "c2NyaXB0b3JQcm90bxJICg9leHRlbnNpb25fcmFuZ2UYBSADKAsyLy5nb29n" + + "bGUucHJvdG9idWYuRGVzY3JpcHRvclByb3RvLkV4dGVuc2lvblJhbmdlEjAK" + + "B29wdGlvbnMYByABKAsyHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlv" + + "bnMaLAoORXh0ZW5zaW9uUmFuZ2USDQoFc3RhcnQYASABKAUSCwoDZW5kGAIg" + + "ASgFIpQFChRGaWVsZERlc2NyaXB0b3JQcm90bxIMCgRuYW1lGAEgASgJEg4K" + + "Bm51bWJlchgDIAEoBRI6CgVsYWJlbBgEIAEoDjIrLmdvb2dsZS5wcm90b2J1" + + "Zi5GaWVsZERlc2NyaXB0b3JQcm90by5MYWJlbBI4CgR0eXBlGAUgASgOMiou" + + "Z29vZ2xlLnByb3RvYnVmLkZpZWxkRGVzY3JpcHRvclByb3RvLlR5cGUSEQoJ" + + "dHlwZV9uYW1lGAYgASgJEhAKCGV4dGVuZGVlGAIgASgJEhUKDWRlZmF1bHRf" + + "dmFsdWUYByABKAkSLgoHb3B0aW9ucxgIIAEoCzIdLmdvb2dsZS5wcm90b2J1" + + "Zi5GaWVsZE9wdGlvbnMitgIKBFR5cGUSDwoLVFlQRV9ET1VCTEUQARIOCgpU" + + "WVBFX0ZMT0FUEAISDgoKVFlQRV9JTlQ2NBADEg8KC1RZUEVfVUlOVDY0EAQS" + + "DgoKVFlQRV9JTlQzMhAFEhAKDFRZUEVfRklYRUQ2NBAGEhAKDFRZUEVfRklY" + + "RUQzMhAHEg0KCVRZUEVfQk9PTBAIEg8KC1RZUEVfU1RSSU5HEAkSDgoKVFlQ" + + "RV9HUk9VUBAKEhAKDFRZUEVfTUVTU0FHRRALEg4KClRZUEVfQllURVMQDBIP" + + "CgtUWVBFX1VJTlQzMhANEg0KCVRZUEVfRU5VTRAOEhEKDVRZUEVfU0ZJWEVE" + + "MzIQDxIRCg1UWVBFX1NGSVhFRDY0EBASDwoLVFlQRV9TSU5UMzIQERIPCgtU" + + "WVBFX1NJTlQ2NBASIkMKBUxhYmVsEhIKDkxBQkVMX09QVElPTkFMEAESEgoO" + + "TEFCRUxfUkVRVUlSRUQQAhISCg5MQUJFTF9SRVBFQVRFRBADIowBChNFbnVt" + + "RGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSOAoFdmFsdWUYAiADKAsy" + + "KS5nb29nbGUucHJvdG9idWYuRW51bVZhbHVlRGVzY3JpcHRvclByb3RvEi0K" + + "B29wdGlvbnMYAyABKAsyHC5nb29nbGUucHJvdG9idWYuRW51bU9wdGlvbnMi" + + "bAoYRW51bVZhbHVlRGVzY3JpcHRvclByb3RvEgwKBG5hbWUYASABKAkSDgoG" + + "bnVtYmVyGAIgASgFEjIKB29wdGlvbnMYAyABKAsyIS5nb29nbGUucHJvdG9i" + + "dWYuRW51bVZhbHVlT3B0aW9ucyKQAQoWU2VydmljZURlc2NyaXB0b3JQcm90" + + "bxIMCgRuYW1lGAEgASgJEjYKBm1ldGhvZBgCIAMoCzImLmdvb2dsZS5wcm90" + + "b2J1Zi5NZXRob2REZXNjcmlwdG9yUHJvdG8SMAoHb3B0aW9ucxgDIAEoCzIf" + + "Lmdvb2dsZS5wcm90b2J1Zi5TZXJ2aWNlT3B0aW9ucyJ/ChVNZXRob2REZXNj" + + "cmlwdG9yUHJvdG8SDAoEbmFtZRgBIAEoCRISCgppbnB1dF90eXBlGAIgASgJ" + + "EhMKC291dHB1dF90eXBlGAMgASgJEi8KB29wdGlvbnMYBCABKAsyHi5nb29n" + + "bGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucyKrAgoLRmlsZU9wdGlvbnMSFAoM" + + "amF2YV9wYWNrYWdlGAEgASgJEhwKFGphdmFfb3V0ZXJfY2xhc3NuYW1lGAgg" + + "ASgJEiIKE2phdmFfbXVsdGlwbGVfZmlsZXMYCiABKAg6BWZhbHNlEkoKDG9w" + + "dGltaXplX2ZvchgJIAEoDjIpLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9u" + + "cy5PcHRpbWl6ZU1vZGU6CUNPREVfU0laRRJDChR1bmludGVycHJldGVkX29w" + + "dGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9w" + + "dGlvbiIoCgxPcHRpbWl6ZU1vZGUSCQoFU1BFRUQQARINCglDT0RFX1NJWkUQ" + + "AioJCOgHEICAgIACIogBCg5NZXNzYWdlT3B0aW9ucxImChdtZXNzYWdlX3Nl" + + "dF93aXJlX2Zvcm1hdBgBIAEoCDoFZmFsc2USQwoUdW5pbnRlcnByZXRlZF9v" + + "cHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVmLlVuaW50ZXJwcmV0ZWRP" + + "cHRpb24qCQjoBxCAgICAAiLVAQoMRmllbGRPcHRpb25zEjIKBWN0eXBlGAEg" + + "ASgOMiMuZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucy5DVHlwZRIcChRl" + + "eHBlcmltZW50YWxfbWFwX2tleRgJIAEoCRJDChR1bmludGVycHJldGVkX29w" + + "dGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9w" + + "dGlvbiIjCgVDVHlwZRIICgRDT1JEEAESEAoMU1RSSU5HX1BJRUNFEAIqCQjo" + + "BxCAgICAAiJdCgtFbnVtT3B0aW9ucxJDChR1bmludGVycHJldGVkX29wdGlv" + + "bhjnByADKAsyJC5nb29nbGUucHJvdG9idWYuVW5pbnRlcnByZXRlZE9wdGlv" + + "bioJCOgHEICAgIACImIKEEVudW1WYWx1ZU9wdGlvbnMSQwoUdW5pbnRlcnBy" + + "ZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnByb3RvYnVmLlVuaW50ZXJw" + + "cmV0ZWRPcHRpb24qCQjoBxCAgICAAiJgCg5TZXJ2aWNlT3B0aW9ucxJDChR1" + + "bmludGVycHJldGVkX29wdGlvbhjnByADKAsyJC5nb29nbGUucHJvdG9idWYu" + + "VW5pbnRlcnByZXRlZE9wdGlvbioJCOgHEICAgIACIl8KDU1ldGhvZE9wdGlv" + + "bnMSQwoUdW5pbnRlcnByZXRlZF9vcHRpb24Y5wcgAygLMiQuZ29vZ2xlLnBy" + + "b3RvYnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24qCQjoBxCAgICAAiKFAgoTVW5p" + + "bnRlcnByZXRlZE9wdGlvbhI7CgRuYW1lGAIgAygLMi0uZ29vZ2xlLnByb3Rv" + + "YnVmLlVuaW50ZXJwcmV0ZWRPcHRpb24uTmFtZVBhcnQSGAoQaWRlbnRpZmll" + + "cl92YWx1ZRgDIAEoCRIaChJwb3NpdGl2ZV9pbnRfdmFsdWUYBCABKAQSGgoS" + + "bmVnYXRpdmVfaW50X3ZhbHVlGAUgASgDEhQKDGRvdWJsZV92YWx1ZRgGIAEo" + + "ARIUCgxzdHJpbmdfdmFsdWUYByABKAwaMwoITmFtZVBhcnQSEQoJbmFtZV9w" + + "YXJ0GAEgAigJEhQKDGlzX2V4dGVuc2lvbhgCIAIoCEIpChNjb20uZ29vZ2xl" + + "LnByb3RvYnVmQhBEZXNjcmlwdG9yUHJvdG9zSAE="), + new pbd::FileDescriptor[] { + }); + #endregion + + #region Static variables + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileDescriptorSet__Descriptor + = Descriptor.MessageTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet.Builder> internal__static_google_protobuf_FileDescriptorSet__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorSet.Builder>(internal__static_google_protobuf_FileDescriptorSet__Descriptor, + new string[] { "File", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileDescriptorProto__Descriptor + = Descriptor.MessageTypes[1]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder> internal__static_google_protobuf_FileDescriptorProto__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder>(internal__static_google_protobuf_FileDescriptorProto__Descriptor, + new string[] { "Name", "Package", "Dependency", "MessageType", "EnumType", "Service", "Extension", "Options", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_DescriptorProto__Descriptor + = Descriptor.MessageTypes[2]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder> internal__static_google_protobuf_DescriptorProto__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder>(internal__static_google_protobuf_DescriptorProto__Descriptor, + new string[] { "Name", "Field", "Extension", "NestedType", "EnumType", "ExtensionRange", "Options", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_DescriptorProto_ExtensionRange__Descriptor + = internal__static_google_protobuf_DescriptorProto__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder> internal__static_google_protobuf_DescriptorProto_ExtensionRange__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder>(internal__static_google_protobuf_DescriptorProto_ExtensionRange__Descriptor, + new string[] { "Start", "End", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FieldDescriptorProto__Descriptor + = Descriptor.MessageTypes[3]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder> internal__static_google_protobuf_FieldDescriptorProto__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder>(internal__static_google_protobuf_FieldDescriptorProto__Descriptor, + new string[] { "Name", "Number", "Label", "Type", "TypeName", "Extendee", "DefaultValue", "Options", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumDescriptorProto__Descriptor + = Descriptor.MessageTypes[4]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder> internal__static_google_protobuf_EnumDescriptorProto__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder>(internal__static_google_protobuf_EnumDescriptorProto__Descriptor, + new string[] { "Name", "Value", "Options", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumValueDescriptorProto__Descriptor + = Descriptor.MessageTypes[5]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder> internal__static_google_protobuf_EnumValueDescriptorProto__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder>(internal__static_google_protobuf_EnumValueDescriptorProto__Descriptor, + new string[] { "Name", "Number", "Options", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_ServiceDescriptorProto__Descriptor + = Descriptor.MessageTypes[6]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder> internal__static_google_protobuf_ServiceDescriptorProto__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder>(internal__static_google_protobuf_ServiceDescriptorProto__Descriptor, + new string[] { "Name", "Method", "Options", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MethodDescriptorProto__Descriptor + = Descriptor.MessageTypes[7]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder> internal__static_google_protobuf_MethodDescriptorProto__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder>(internal__static_google_protobuf_MethodDescriptorProto__Descriptor, + new string[] { "Name", "InputType", "OutputType", "Options", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileOptions__Descriptor + = Descriptor.MessageTypes[8]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileOptions, global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder> internal__static_google_protobuf_FileOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileOptions, global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder>(internal__static_google_protobuf_FileOptions__Descriptor, + new string[] { "JavaPackage", "JavaOuterClassname", "JavaMultipleFiles", "OptimizeFor", "UninterpretedOption", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MessageOptions__Descriptor + = Descriptor.MessageTypes[9]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions, global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder> internal__static_google_protobuf_MessageOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions, global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder>(internal__static_google_protobuf_MessageOptions__Descriptor, + new string[] { "MessageSetWireFormat", "UninterpretedOption", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FieldOptions__Descriptor + = Descriptor.MessageTypes[10]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder> internal__static_google_protobuf_FieldOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder>(internal__static_google_protobuf_FieldOptions__Descriptor, + new string[] { "Ctype", "ExperimentalMapKey", "UninterpretedOption", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumOptions__Descriptor + = Descriptor.MessageTypes[11]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder> internal__static_google_protobuf_EnumOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder>(internal__static_google_protobuf_EnumOptions__Descriptor, + new string[] { "UninterpretedOption", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumValueOptions__Descriptor + = Descriptor.MessageTypes[12]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder> internal__static_google_protobuf_EnumValueOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder>(internal__static_google_protobuf_EnumValueOptions__Descriptor, + new string[] { "UninterpretedOption", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_ServiceOptions__Descriptor + = Descriptor.MessageTypes[13]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder> internal__static_google_protobuf_ServiceOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder>(internal__static_google_protobuf_ServiceOptions__Descriptor, + new string[] { "UninterpretedOption", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MethodOptions__Descriptor + = Descriptor.MessageTypes[14]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder> internal__static_google_protobuf_MethodOptions__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder>(internal__static_google_protobuf_MethodOptions__Descriptor, + new string[] { "UninterpretedOption", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_UninterpretedOption__Descriptor + = Descriptor.MessageTypes[15]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder> internal__static_google_protobuf_UninterpretedOption__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder>(internal__static_google_protobuf_UninterpretedOption__Descriptor, + new string[] { "Name", "IdentifierValue", "PositiveIntValue", "NegativeIntValue", "DoubleValue", "StringValue", }); + internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_UninterpretedOption_NamePart__Descriptor + = internal__static_google_protobuf_UninterpretedOption__Descriptor.NestedTypes[0]; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder> internal__static_google_protobuf_UninterpretedOption_NamePart__FieldAccessorTable + = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder>(internal__static_google_protobuf_UninterpretedOption_NamePart__Descriptor, + new string[] { "NamePart", "IsExtension", }); + #endregion + } + #region Messages + public sealed partial class FileDescriptorSet : pb::GeneratedMessage<FileDescriptorSet, FileDescriptorSet.Builder> { + private static readonly FileDescriptorSet defaultInstance = new Builder().BuildPartial(); + public static FileDescriptorSet DefaultInstance { + get { return defaultInstance; } + } + + public override FileDescriptorSet DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override FileDescriptorSet ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileDescriptorSet__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<FileDescriptorSet, FileDescriptorSet.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileDescriptorSet__FieldAccessorTable; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> file_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> FileList { + get { return file_; } + } + public int FileCount { + get { return file_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto GetFile(int index) { + return file_[index]; + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto element in FileList) { + if (!element.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto element in FileList) { + output.WriteMessage(1, element); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto element in FileList) { + size += pb::CodedOutputStream.ComputeMessageSize(1, element); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static FileDescriptorSet ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FileDescriptorSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FileDescriptorSet ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FileDescriptorSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FileDescriptorSet ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FileDescriptorSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static FileDescriptorSet ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FileDescriptorSet ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(FileDescriptorSet prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<FileDescriptorSet, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + FileDescriptorSet result = new FileDescriptorSet(); + + protected override FileDescriptorSet MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new FileDescriptorSet(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return FileDescriptorSet.Descriptor; } + } + + public override FileDescriptorSet DefaultInstanceForType { + get { return FileDescriptorSet.DefaultInstance; } + } + + public override FileDescriptorSet BuildPartial() { + result.file_.MakeReadOnly(); + FileDescriptorSet returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is FileDescriptorSet) { + return MergeFrom((FileDescriptorSet) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(FileDescriptorSet other) { + if (other == FileDescriptorSet.DefaultInstance) return this; + if (other.file_.Count != 0) { + base.AddRange(other.file_, result.file_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddFile(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> FileList { + get { return result.file_; } + } + public int FileCount { + get { return result.FileCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto GetFile(int index) { + return result.GetFile(index); + } + public Builder SetFile(int index, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto value) { + result.file_[index] = value; + return this; + } + public Builder SetFile(int index, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder builderForValue) { + result.file_[index] = builderForValue.Build(); + return this; + } + public Builder AddFile(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto value) { + result.file_.Add(value); + return this; + } + public Builder AddFile(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder builderForValue) { + result.file_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeFile(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto> values) { + base.AddRange(values, result.file_); + return this; + } + public Builder ClearFile() { + result.file_.Clear(); + return this; + } + } + } + + public sealed partial class FileDescriptorProto : pb::GeneratedMessage<FileDescriptorProto, FileDescriptorProto.Builder> { + private static readonly FileDescriptorProto defaultInstance = new Builder().BuildPartial(); + public static FileDescriptorProto DefaultInstance { + get { return defaultInstance; } + } + + public override FileDescriptorProto DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override FileDescriptorProto ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileDescriptorProto__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<FileDescriptorProto, FileDescriptorProto.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileDescriptorProto__FieldAccessorTable; } + } + + private bool hasName; + private string name_ = ""; + public bool HasName { + get { return hasName; } + } + public string Name { + get { return name_; } + } + + private bool hasPackage; + private string package_ = ""; + public bool HasPackage { + get { return hasPackage; } + } + public string Package { + get { return package_; } + } + + private pbc::PopsicleList<string> dependency_ = new pbc::PopsicleList<string>(); + public scg::IList<string> DependencyList { + get { return pbc::Lists.AsReadOnly(dependency_); } + } + public int DependencyCount { + get { return dependency_.Count; } + } + public string GetDependency(int index) { + return dependency_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> messageType_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> MessageTypeList { + get { return messageType_; } + } + public int MessageTypeCount { + get { return messageType_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetMessageType(int index) { + return messageType_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList { + get { return enumType_; } + } + public int EnumTypeCount { + get { return enumType_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) { + return enumType_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> service_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> ServiceList { + get { return service_; } + } + public int ServiceCount { + get { return service_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto GetService(int index) { + return service_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList { + get { return extension_; } + } + public int ExtensionCount { + get { return extension_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) { + return extension_[index]; + } + + private bool hasOptions; + private global::Google.ProtocolBuffers.DescriptorProtos.FileOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance; + public bool HasOptions { + get { return hasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions Options { + get { return options_; } + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in MessageTypeList) { + if (!element.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) { + if (!element.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto element in ServiceList) { + if (!element.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) { + if (!element.IsInitialized) return false; + } + if (HasOptions) { + if (!Options.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasName) { + output.WriteString(1, Name); + } + if (HasPackage) { + output.WriteString(2, Package); + } + foreach (string element in DependencyList) { + output.WriteString(3, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in MessageTypeList) { + output.WriteMessage(4, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) { + output.WriteMessage(5, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto element in ServiceList) { + output.WriteMessage(6, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) { + output.WriteMessage(7, element); + } + if (HasOptions) { + output.WriteMessage(8, Options); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasName) { + size += pb::CodedOutputStream.ComputeStringSize(1, Name); + } + if (HasPackage) { + size += pb::CodedOutputStream.ComputeStringSize(2, Package); + } + foreach (string element in DependencyList) { + size += pb::CodedOutputStream.ComputeStringSize(3, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in MessageTypeList) { + size += pb::CodedOutputStream.ComputeMessageSize(4, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) { + size += pb::CodedOutputStream.ComputeMessageSize(5, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto element in ServiceList) { + size += pb::CodedOutputStream.ComputeMessageSize(6, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) { + size += pb::CodedOutputStream.ComputeMessageSize(7, element); + } + if (HasOptions) { + size += pb::CodedOutputStream.ComputeMessageSize(8, Options); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static FileDescriptorProto ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FileDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FileDescriptorProto ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FileDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FileDescriptorProto ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FileDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static FileDescriptorProto ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FileDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(FileDescriptorProto prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<FileDescriptorProto, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + FileDescriptorProto result = new FileDescriptorProto(); + + protected override FileDescriptorProto MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new FileDescriptorProto(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return FileDescriptorProto.Descriptor; } + } + + public override FileDescriptorProto DefaultInstanceForType { + get { return FileDescriptorProto.DefaultInstance; } + } + + public override FileDescriptorProto BuildPartial() { + result.dependency_.MakeReadOnly(); + result.messageType_.MakeReadOnly(); + result.enumType_.MakeReadOnly(); + result.service_.MakeReadOnly(); + result.extension_.MakeReadOnly(); + FileDescriptorProto returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is FileDescriptorProto) { + return MergeFrom((FileDescriptorProto) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(FileDescriptorProto other) { + if (other == FileDescriptorProto.DefaultInstance) return this; + if (other.HasName) { + Name = other.Name; + } + if (other.HasPackage) { + Package = other.Package; + } + if (other.dependency_.Count != 0) { + base.AddRange(other.dependency_, result.dependency_); + } + if (other.messageType_.Count != 0) { + base.AddRange(other.messageType_, result.messageType_); + } + if (other.enumType_.Count != 0) { + base.AddRange(other.enumType_, result.enumType_); + } + if (other.service_.Count != 0) { + base.AddRange(other.service_, result.service_); + } + if (other.extension_.Count != 0) { + base.AddRange(other.extension_, result.extension_); + } + if (other.HasOptions) { + MergeOptions(other.Options); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Package = input.ReadString(); + break; + } + case 26: { + AddDependency(input.ReadString()); + break; + } + case 34: { + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddMessageType(subBuilder.BuildPartial()); + break; + } + case 42: { + global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddEnumType(subBuilder.BuildPartial()); + break; + } + case 50: { + global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddService(subBuilder.BuildPartial()); + break; + } + case 58: { + global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddExtension(subBuilder.BuildPartial()); + break; + } + case 66: { + global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder(); + if (HasOptions) { + subBuilder.MergeFrom(Options); + } + input.ReadMessage(subBuilder, extensionRegistry); + Options = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasName { + get { return result.HasName; } + } + public string Name { + get { return result.Name; } + set { SetName(value); } + } + public Builder SetName(string value) { + result.hasName = true; + result.name_ = value; + return this; + } + public Builder ClearName() { + result.hasName = false; + result.name_ = ""; + return this; + } + + public bool HasPackage { + get { return result.HasPackage; } + } + public string Package { + get { return result.Package; } + set { SetPackage(value); } + } + public Builder SetPackage(string value) { + result.hasPackage = true; + result.package_ = value; + return this; + } + public Builder ClearPackage() { + result.hasPackage = false; + result.package_ = ""; + return this; + } + + public scg::IList<string> DependencyList { + get { return result.dependency_; } + } + public int DependencyCount { + get { return result.DependencyCount; } + } + public string GetDependency(int index) { + return result.GetDependency(index); + } + public Builder SetDependency(int index, string value) { + result.dependency_[index] = value; + return this; + } + public Builder AddDependency(string value) { + result.dependency_.Add(value); + return this; + } + public Builder AddRangeDependency(scg::IEnumerable<string> values) { + base.AddRange(values, result.dependency_); + return this; + } + public Builder ClearDependency() { + result.dependency_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> MessageTypeList { + get { return result.messageType_; } + } + public int MessageTypeCount { + get { return result.MessageTypeCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetMessageType(int index) { + return result.GetMessageType(index); + } + public Builder SetMessageType(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto value) { + result.messageType_[index] = value; + return this; + } + public Builder SetMessageType(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder builderForValue) { + result.messageType_[index] = builderForValue.Build(); + return this; + } + public Builder AddMessageType(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto value) { + result.messageType_.Add(value); + return this; + } + public Builder AddMessageType(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder builderForValue) { + result.messageType_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeMessageType(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> values) { + base.AddRange(values, result.messageType_); + return this; + } + public Builder ClearMessageType() { + result.messageType_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList { + get { return result.enumType_; } + } + public int EnumTypeCount { + get { return result.EnumTypeCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) { + return result.GetEnumType(index); + } + public Builder SetEnumType(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto value) { + result.enumType_[index] = value; + return this; + } + public Builder SetEnumType(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder builderForValue) { + result.enumType_[index] = builderForValue.Build(); + return this; + } + public Builder AddEnumType(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto value) { + result.enumType_.Add(value); + return this; + } + public Builder AddEnumType(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder builderForValue) { + result.enumType_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeEnumType(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> values) { + base.AddRange(values, result.enumType_); + return this; + } + public Builder ClearEnumType() { + result.enumType_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> ServiceList { + get { return result.service_; } + } + public int ServiceCount { + get { return result.ServiceCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto GetService(int index) { + return result.GetService(index); + } + public Builder SetService(int index, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto value) { + result.service_[index] = value; + return this; + } + public Builder SetService(int index, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder builderForValue) { + result.service_[index] = builderForValue.Build(); + return this; + } + public Builder AddService(global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto value) { + result.service_.Add(value); + return this; + } + public Builder AddService(global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder builderForValue) { + result.service_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeService(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> values) { + base.AddRange(values, result.service_); + return this; + } + public Builder ClearService() { + result.service_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList { + get { return result.extension_; } + } + public int ExtensionCount { + get { return result.ExtensionCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) { + return result.GetExtension(index); + } + public Builder SetExtension(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) { + result.extension_[index] = value; + return this; + } + public Builder SetExtension(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) { + result.extension_[index] = builderForValue.Build(); + return this; + } + public Builder AddExtension(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) { + result.extension_.Add(value); + return this; + } + public Builder AddExtension(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) { + result.extension_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeExtension(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> values) { + base.AddRange(values, result.extension_); + return this; + } + public Builder ClearExtension() { + result.extension_.Clear(); + return this; + } + + public bool HasOptions { + get { return result.HasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions Options { + get { return result.Options; } + set { SetOptions(value); } + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions value) { + result.hasOptions = true; + result.options_ = value; + return this; + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder builderForValue) { + result.hasOptions = true; + result.options_ = builderForValue.Build(); + return this; + } + public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions value) { + if (result.HasOptions && + result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance) { + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial(); + } else { + result.options_ = value; + } + result.hasOptions = true; + return this; + } + public Builder ClearOptions() { + result.hasOptions = false; + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance; + return this; + } + } + } + + public sealed partial class DescriptorProto : pb::GeneratedMessage<DescriptorProto, DescriptorProto.Builder> { + private static readonly DescriptorProto defaultInstance = new Builder().BuildPartial(); + public static DescriptorProto DefaultInstance { + get { return defaultInstance; } + } + + public override DescriptorProto DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override DescriptorProto ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_DescriptorProto__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<DescriptorProto, DescriptorProto.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_DescriptorProto__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class ExtensionRange : pb::GeneratedMessage<ExtensionRange, ExtensionRange.Builder> { + private static readonly ExtensionRange defaultInstance = new Builder().BuildPartial(); + public static ExtensionRange DefaultInstance { + get { return defaultInstance; } + } + + public override ExtensionRange DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ExtensionRange ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_DescriptorProto_ExtensionRange__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ExtensionRange, ExtensionRange.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_DescriptorProto_ExtensionRange__FieldAccessorTable; } + } + + private bool hasStart; + private int start_ = 0; + public bool HasStart { + get { return hasStart; } + } + public int Start { + get { return start_; } + } + + private bool hasEnd; + private int end_ = 0; + public bool HasEnd { + get { return hasEnd; } + } + public int End { + get { return end_; } + } + + public override bool IsInitialized { + get { + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasStart) { + output.WriteInt32(1, Start); + } + if (HasEnd) { + output.WriteInt32(2, End); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasStart) { + size += pb::CodedOutputStream.ComputeInt32Size(1, Start); + } + if (HasEnd) { + size += pb::CodedOutputStream.ComputeInt32Size(2, End); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ExtensionRange ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ExtensionRange ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ExtensionRange ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ExtensionRange ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ExtensionRange ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ExtensionRange ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ExtensionRange ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ExtensionRange ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ExtensionRange prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<ExtensionRange, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ExtensionRange result = new ExtensionRange(); + + protected override ExtensionRange MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ExtensionRange(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ExtensionRange.Descriptor; } + } + + public override ExtensionRange DefaultInstanceForType { + get { return ExtensionRange.DefaultInstance; } + } + + public override ExtensionRange BuildPartial() { + ExtensionRange returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ExtensionRange) { + return MergeFrom((ExtensionRange) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ExtensionRange other) { + if (other == ExtensionRange.DefaultInstance) return this; + if (other.HasStart) { + Start = other.Start; + } + if (other.HasEnd) { + End = other.End; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + Start = input.ReadInt32(); + break; + } + case 16: { + End = input.ReadInt32(); + break; + } + } + } + } + + + public bool HasStart { + get { return result.HasStart; } + } + public int Start { + get { return result.Start; } + set { SetStart(value); } + } + public Builder SetStart(int value) { + result.hasStart = true; + result.start_ = value; + return this; + } + public Builder ClearStart() { + result.hasStart = false; + result.start_ = 0; + return this; + } + + public bool HasEnd { + get { return result.HasEnd; } + } + public int End { + get { return result.End; } + set { SetEnd(value); } + } + public Builder SetEnd(int value) { + result.hasEnd = true; + result.end_ = value; + return this; + } + public Builder ClearEnd() { + result.hasEnd = false; + result.end_ = 0; + return this; + } + } + } + + } + #endregion + + private bool hasName; + private string name_ = ""; + public bool HasName { + get { return hasName; } + } + public string Name { + get { return name_; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> field_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> FieldList { + get { return field_; } + } + public int FieldCount { + get { return field_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetField(int index) { + return field_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList { + get { return extension_; } + } + public int ExtensionCount { + get { return extension_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) { + return extension_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> nestedType_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> NestedTypeList { + get { return nestedType_; } + } + public int NestedTypeCount { + get { return nestedType_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetNestedType(int index) { + return nestedType_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList { + get { return enumType_; } + } + public int EnumTypeCount { + get { return enumType_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) { + return enumType_[index]; + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> extensionRange_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> ExtensionRangeList { + get { return extensionRange_; } + } + public int ExtensionRangeCount { + get { return extensionRange_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange GetExtensionRange(int index) { + return extensionRange_[index]; + } + + private bool hasOptions; + private global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance; + public bool HasOptions { + get { return hasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions Options { + get { return options_; } + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in FieldList) { + if (!element.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) { + if (!element.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in NestedTypeList) { + if (!element.IsInitialized) return false; + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) { + if (!element.IsInitialized) return false; + } + if (HasOptions) { + if (!Options.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasName) { + output.WriteString(1, Name); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in FieldList) { + output.WriteMessage(2, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in NestedTypeList) { + output.WriteMessage(3, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) { + output.WriteMessage(4, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange element in ExtensionRangeList) { + output.WriteMessage(5, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) { + output.WriteMessage(6, element); + } + if (HasOptions) { + output.WriteMessage(7, Options); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasName) { + size += pb::CodedOutputStream.ComputeStringSize(1, Name); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in FieldList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) { + size += pb::CodedOutputStream.ComputeMessageSize(6, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in NestedTypeList) { + size += pb::CodedOutputStream.ComputeMessageSize(3, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) { + size += pb::CodedOutputStream.ComputeMessageSize(4, element); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange element in ExtensionRangeList) { + size += pb::CodedOutputStream.ComputeMessageSize(5, element); + } + if (HasOptions) { + size += pb::CodedOutputStream.ComputeMessageSize(7, Options); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static DescriptorProto ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DescriptorProto ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static DescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static DescriptorProto ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static DescriptorProto ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static DescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(DescriptorProto prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<DescriptorProto, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + DescriptorProto result = new DescriptorProto(); + + protected override DescriptorProto MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new DescriptorProto(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return DescriptorProto.Descriptor; } + } + + public override DescriptorProto DefaultInstanceForType { + get { return DescriptorProto.DefaultInstance; } + } + + public override DescriptorProto BuildPartial() { + result.field_.MakeReadOnly(); + result.extension_.MakeReadOnly(); + result.nestedType_.MakeReadOnly(); + result.enumType_.MakeReadOnly(); + result.extensionRange_.MakeReadOnly(); + DescriptorProto returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is DescriptorProto) { + return MergeFrom((DescriptorProto) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(DescriptorProto other) { + if (other == DescriptorProto.DefaultInstance) return this; + if (other.HasName) { + Name = other.Name; + } + if (other.field_.Count != 0) { + base.AddRange(other.field_, result.field_); + } + if (other.extension_.Count != 0) { + base.AddRange(other.extension_, result.extension_); + } + if (other.nestedType_.Count != 0) { + base.AddRange(other.nestedType_, result.nestedType_); + } + if (other.enumType_.Count != 0) { + base.AddRange(other.enumType_, result.enumType_); + } + if (other.extensionRange_.Count != 0) { + base.AddRange(other.extensionRange_, result.extensionRange_); + } + if (other.HasOptions) { + MergeOptions(other.Options); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddField(subBuilder.BuildPartial()); + break; + } + case 26: { + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddNestedType(subBuilder.BuildPartial()); + break; + } + case 34: { + global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddEnumType(subBuilder.BuildPartial()); + break; + } + case 42: { + global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddExtensionRange(subBuilder.BuildPartial()); + break; + } + case 50: { + global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddExtension(subBuilder.BuildPartial()); + break; + } + case 58: { + global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder(); + if (HasOptions) { + subBuilder.MergeFrom(Options); + } + input.ReadMessage(subBuilder, extensionRegistry); + Options = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasName { + get { return result.HasName; } + } + public string Name { + get { return result.Name; } + set { SetName(value); } + } + public Builder SetName(string value) { + result.hasName = true; + result.name_ = value; + return this; + } + public Builder ClearName() { + result.hasName = false; + result.name_ = ""; + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> FieldList { + get { return result.field_; } + } + public int FieldCount { + get { return result.FieldCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetField(int index) { + return result.GetField(index); + } + public Builder SetField(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) { + result.field_[index] = value; + return this; + } + public Builder SetField(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) { + result.field_[index] = builderForValue.Build(); + return this; + } + public Builder AddField(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) { + result.field_.Add(value); + return this; + } + public Builder AddField(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) { + result.field_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeField(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> values) { + base.AddRange(values, result.field_); + return this; + } + public Builder ClearField() { + result.field_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList { + get { return result.extension_; } + } + public int ExtensionCount { + get { return result.ExtensionCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) { + return result.GetExtension(index); + } + public Builder SetExtension(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) { + result.extension_[index] = value; + return this; + } + public Builder SetExtension(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) { + result.extension_[index] = builderForValue.Build(); + return this; + } + public Builder AddExtension(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) { + result.extension_.Add(value); + return this; + } + public Builder AddExtension(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) { + result.extension_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeExtension(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> values) { + base.AddRange(values, result.extension_); + return this; + } + public Builder ClearExtension() { + result.extension_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> NestedTypeList { + get { return result.nestedType_; } + } + public int NestedTypeCount { + get { return result.NestedTypeCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetNestedType(int index) { + return result.GetNestedType(index); + } + public Builder SetNestedType(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto value) { + result.nestedType_[index] = value; + return this; + } + public Builder SetNestedType(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder builderForValue) { + result.nestedType_[index] = builderForValue.Build(); + return this; + } + public Builder AddNestedType(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto value) { + result.nestedType_.Add(value); + return this; + } + public Builder AddNestedType(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder builderForValue) { + result.nestedType_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeNestedType(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> values) { + base.AddRange(values, result.nestedType_); + return this; + } + public Builder ClearNestedType() { + result.nestedType_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList { + get { return result.enumType_; } + } + public int EnumTypeCount { + get { return result.EnumTypeCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) { + return result.GetEnumType(index); + } + public Builder SetEnumType(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto value) { + result.enumType_[index] = value; + return this; + } + public Builder SetEnumType(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder builderForValue) { + result.enumType_[index] = builderForValue.Build(); + return this; + } + public Builder AddEnumType(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto value) { + result.enumType_.Add(value); + return this; + } + public Builder AddEnumType(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder builderForValue) { + result.enumType_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeEnumType(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> values) { + base.AddRange(values, result.enumType_); + return this; + } + public Builder ClearEnumType() { + result.enumType_.Clear(); + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> ExtensionRangeList { + get { return result.extensionRange_; } + } + public int ExtensionRangeCount { + get { return result.ExtensionRangeCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange GetExtensionRange(int index) { + return result.GetExtensionRange(index); + } + public Builder SetExtensionRange(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange value) { + result.extensionRange_[index] = value; + return this; + } + public Builder SetExtensionRange(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder builderForValue) { + result.extensionRange_[index] = builderForValue.Build(); + return this; + } + public Builder AddExtensionRange(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange value) { + result.extensionRange_.Add(value); + return this; + } + public Builder AddExtensionRange(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder builderForValue) { + result.extensionRange_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeExtensionRange(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> values) { + base.AddRange(values, result.extensionRange_); + return this; + } + public Builder ClearExtensionRange() { + result.extensionRange_.Clear(); + return this; + } + + public bool HasOptions { + get { return result.HasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions Options { + get { return result.Options; } + set { SetOptions(value); } + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions value) { + result.hasOptions = true; + result.options_ = value; + return this; + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder builderForValue) { + result.hasOptions = true; + result.options_ = builderForValue.Build(); + return this; + } + public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions value) { + if (result.HasOptions && + result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance) { + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial(); + } else { + result.options_ = value; + } + result.hasOptions = true; + return this; + } + public Builder ClearOptions() { + result.hasOptions = false; + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance; + return this; + } + } + } + + public sealed partial class FieldDescriptorProto : pb::GeneratedMessage<FieldDescriptorProto, FieldDescriptorProto.Builder> { + private static readonly FieldDescriptorProto defaultInstance = new Builder().BuildPartial(); + public static FieldDescriptorProto DefaultInstance { + get { return defaultInstance; } + } + + public override FieldDescriptorProto DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override FieldDescriptorProto ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FieldDescriptorProto__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<FieldDescriptorProto, FieldDescriptorProto.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FieldDescriptorProto__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum Type { + TYPE_DOUBLE = 1, + TYPE_FLOAT = 2, + TYPE_INT64 = 3, + TYPE_UINT64 = 4, + TYPE_INT32 = 5, + TYPE_FIXED64 = 6, + TYPE_FIXED32 = 7, + TYPE_BOOL = 8, + TYPE_STRING = 9, + TYPE_GROUP = 10, + TYPE_MESSAGE = 11, + TYPE_BYTES = 12, + TYPE_UINT32 = 13, + TYPE_ENUM = 14, + TYPE_SFIXED32 = 15, + TYPE_SFIXED64 = 16, + TYPE_SINT32 = 17, + TYPE_SINT64 = 18, + } + + public enum Label { + LABEL_OPTIONAL = 1, + LABEL_REQUIRED = 2, + LABEL_REPEATED = 3, + } + + } + #endregion + + private bool hasName; + private string name_ = ""; + public bool HasName { + get { return hasName; } + } + public string Name { + get { return name_; } + } + + private bool hasNumber; + private int number_ = 0; + public bool HasNumber { + get { return hasNumber; } + } + public int Number { + get { return number_; } + } + + private bool hasLabel; + private global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label label_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label.LABEL_OPTIONAL; + public bool HasLabel { + get { return hasLabel; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label Label { + get { return label_; } + } + + private bool hasType; + private global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type type_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type.TYPE_DOUBLE; + public bool HasType { + get { return hasType; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type Type { + get { return type_; } + } + + private bool hasTypeName; + private string typeName_ = ""; + public bool HasTypeName { + get { return hasTypeName; } + } + public string TypeName { + get { return typeName_; } + } + + private bool hasExtendee; + private string extendee_ = ""; + public bool HasExtendee { + get { return hasExtendee; } + } + public string Extendee { + get { return extendee_; } + } + + private bool hasDefaultValue; + private string defaultValue_ = ""; + public bool HasDefaultValue { + get { return hasDefaultValue; } + } + public string DefaultValue { + get { return defaultValue_; } + } + + private bool hasOptions; + private global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance; + public bool HasOptions { + get { return hasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions Options { + get { return options_; } + } + + public override bool IsInitialized { + get { + if (HasOptions) { + if (!Options.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasName) { + output.WriteString(1, Name); + } + if (HasExtendee) { + output.WriteString(2, Extendee); + } + if (HasNumber) { + output.WriteInt32(3, Number); + } + if (HasLabel) { + output.WriteEnum(4, (int) Label); + } + if (HasType) { + output.WriteEnum(5, (int) Type); + } + if (HasTypeName) { + output.WriteString(6, TypeName); + } + if (HasDefaultValue) { + output.WriteString(7, DefaultValue); + } + if (HasOptions) { + output.WriteMessage(8, Options); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasName) { + size += pb::CodedOutputStream.ComputeStringSize(1, Name); + } + if (HasNumber) { + size += pb::CodedOutputStream.ComputeInt32Size(3, Number); + } + if (HasLabel) { + size += pb::CodedOutputStream.ComputeEnumSize(4, (int) Label); + } + if (HasType) { + size += pb::CodedOutputStream.ComputeEnumSize(5, (int) Type); + } + if (HasTypeName) { + size += pb::CodedOutputStream.ComputeStringSize(6, TypeName); + } + if (HasExtendee) { + size += pb::CodedOutputStream.ComputeStringSize(2, Extendee); + } + if (HasDefaultValue) { + size += pb::CodedOutputStream.ComputeStringSize(7, DefaultValue); + } + if (HasOptions) { + size += pb::CodedOutputStream.ComputeMessageSize(8, Options); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static FieldDescriptorProto ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FieldDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FieldDescriptorProto ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FieldDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FieldDescriptorProto ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FieldDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static FieldDescriptorProto ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FieldDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(FieldDescriptorProto prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<FieldDescriptorProto, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + FieldDescriptorProto result = new FieldDescriptorProto(); + + protected override FieldDescriptorProto MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new FieldDescriptorProto(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return FieldDescriptorProto.Descriptor; } + } + + public override FieldDescriptorProto DefaultInstanceForType { + get { return FieldDescriptorProto.DefaultInstance; } + } + + public override FieldDescriptorProto BuildPartial() { + FieldDescriptorProto returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is FieldDescriptorProto) { + return MergeFrom((FieldDescriptorProto) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(FieldDescriptorProto other) { + if (other == FieldDescriptorProto.DefaultInstance) return this; + if (other.HasName) { + Name = other.Name; + } + if (other.HasNumber) { + Number = other.Number; + } + if (other.HasLabel) { + Label = other.Label; + } + if (other.HasType) { + Type = other.Type; + } + if (other.HasTypeName) { + TypeName = other.TypeName; + } + if (other.HasExtendee) { + Extendee = other.Extendee; + } + if (other.HasDefaultValue) { + DefaultValue = other.DefaultValue; + } + if (other.HasOptions) { + MergeOptions(other.Options); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + Extendee = input.ReadString(); + break; + } + case 24: { + Number = input.ReadInt32(); + break; + } + case 32: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label), rawValue)) { + unknownFields.MergeVarintField(4, (ulong) rawValue); + } else { + Label = (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label) rawValue; + } + break; + } + case 40: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type), rawValue)) { + unknownFields.MergeVarintField(5, (ulong) rawValue); + } else { + Type = (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type) rawValue; + } + break; + } + case 50: { + TypeName = input.ReadString(); + break; + } + case 58: { + DefaultValue = input.ReadString(); + break; + } + case 66: { + global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder(); + if (HasOptions) { + subBuilder.MergeFrom(Options); + } + input.ReadMessage(subBuilder, extensionRegistry); + Options = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasName { + get { return result.HasName; } + } + public string Name { + get { return result.Name; } + set { SetName(value); } + } + public Builder SetName(string value) { + result.hasName = true; + result.name_ = value; + return this; + } + public Builder ClearName() { + result.hasName = false; + result.name_ = ""; + return this; + } + + public bool HasNumber { + get { return result.HasNumber; } + } + public int Number { + get { return result.Number; } + set { SetNumber(value); } + } + public Builder SetNumber(int value) { + result.hasNumber = true; + result.number_ = value; + return this; + } + public Builder ClearNumber() { + result.hasNumber = false; + result.number_ = 0; + return this; + } + + public bool HasLabel { + get { return result.HasLabel; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label Label { + get { return result.Label; } + set { SetLabel(value); } + } + public Builder SetLabel(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label value) { + result.hasLabel = true; + result.label_ = value; + return this; + } + public Builder ClearLabel() { + result.hasLabel = false; + result.label_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label.LABEL_OPTIONAL; + return this; + } + + public bool HasType { + get { return result.HasType; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type Type { + get { return result.Type; } + set { SetType(value); } + } + public Builder SetType(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type value) { + result.hasType = true; + result.type_ = value; + return this; + } + public Builder ClearType() { + result.hasType = false; + result.type_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type.TYPE_DOUBLE; + return this; + } + + public bool HasTypeName { + get { return result.HasTypeName; } + } + public string TypeName { + get { return result.TypeName; } + set { SetTypeName(value); } + } + public Builder SetTypeName(string value) { + result.hasTypeName = true; + result.typeName_ = value; + return this; + } + public Builder ClearTypeName() { + result.hasTypeName = false; + result.typeName_ = ""; + return this; + } + + public bool HasExtendee { + get { return result.HasExtendee; } + } + public string Extendee { + get { return result.Extendee; } + set { SetExtendee(value); } + } + public Builder SetExtendee(string value) { + result.hasExtendee = true; + result.extendee_ = value; + return this; + } + public Builder ClearExtendee() { + result.hasExtendee = false; + result.extendee_ = ""; + return this; + } + + public bool HasDefaultValue { + get { return result.HasDefaultValue; } + } + public string DefaultValue { + get { return result.DefaultValue; } + set { SetDefaultValue(value); } + } + public Builder SetDefaultValue(string value) { + result.hasDefaultValue = true; + result.defaultValue_ = value; + return this; + } + public Builder ClearDefaultValue() { + result.hasDefaultValue = false; + result.defaultValue_ = ""; + return this; + } + + public bool HasOptions { + get { return result.HasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions Options { + get { return result.Options; } + set { SetOptions(value); } + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions value) { + result.hasOptions = true; + result.options_ = value; + return this; + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder builderForValue) { + result.hasOptions = true; + result.options_ = builderForValue.Build(); + return this; + } + public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions value) { + if (result.HasOptions && + result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance) { + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial(); + } else { + result.options_ = value; + } + result.hasOptions = true; + return this; + } + public Builder ClearOptions() { + result.hasOptions = false; + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance; + return this; + } + } + } + + public sealed partial class EnumDescriptorProto : pb::GeneratedMessage<EnumDescriptorProto, EnumDescriptorProto.Builder> { + private static readonly EnumDescriptorProto defaultInstance = new Builder().BuildPartial(); + public static EnumDescriptorProto DefaultInstance { + get { return defaultInstance; } + } + + public override EnumDescriptorProto DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override EnumDescriptorProto ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumDescriptorProto__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<EnumDescriptorProto, EnumDescriptorProto.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumDescriptorProto__FieldAccessorTable; } + } + + private bool hasName; + private string name_ = ""; + public bool HasName { + get { return hasName; } + } + public string Name { + get { return name_; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> value_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> ValueList { + get { return value_; } + } + public int ValueCount { + get { return value_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto GetValue(int index) { + return value_[index]; + } + + private bool hasOptions; + private global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance; + public bool HasOptions { + get { return hasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions Options { + get { return options_; } + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto element in ValueList) { + if (!element.IsInitialized) return false; + } + if (HasOptions) { + if (!Options.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasName) { + output.WriteString(1, Name); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto element in ValueList) { + output.WriteMessage(2, element); + } + if (HasOptions) { + output.WriteMessage(3, Options); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasName) { + size += pb::CodedOutputStream.ComputeStringSize(1, Name); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto element in ValueList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + if (HasOptions) { + size += pb::CodedOutputStream.ComputeMessageSize(3, Options); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static EnumDescriptorProto ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static EnumDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static EnumDescriptorProto ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static EnumDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static EnumDescriptorProto ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static EnumDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static EnumDescriptorProto ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static EnumDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(EnumDescriptorProto prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<EnumDescriptorProto, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + EnumDescriptorProto result = new EnumDescriptorProto(); + + protected override EnumDescriptorProto MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new EnumDescriptorProto(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return EnumDescriptorProto.Descriptor; } + } + + public override EnumDescriptorProto DefaultInstanceForType { + get { return EnumDescriptorProto.DefaultInstance; } + } + + public override EnumDescriptorProto BuildPartial() { + result.value_.MakeReadOnly(); + EnumDescriptorProto returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is EnumDescriptorProto) { + return MergeFrom((EnumDescriptorProto) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(EnumDescriptorProto other) { + if (other == EnumDescriptorProto.DefaultInstance) return this; + if (other.HasName) { + Name = other.Name; + } + if (other.value_.Count != 0) { + base.AddRange(other.value_, result.value_); + } + if (other.HasOptions) { + MergeOptions(other.Options); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddValue(subBuilder.BuildPartial()); + break; + } + case 26: { + global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder(); + if (HasOptions) { + subBuilder.MergeFrom(Options); + } + input.ReadMessage(subBuilder, extensionRegistry); + Options = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasName { + get { return result.HasName; } + } + public string Name { + get { return result.Name; } + set { SetName(value); } + } + public Builder SetName(string value) { + result.hasName = true; + result.name_ = value; + return this; + } + public Builder ClearName() { + result.hasName = false; + result.name_ = ""; + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> ValueList { + get { return result.value_; } + } + public int ValueCount { + get { return result.ValueCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto GetValue(int index) { + return result.GetValue(index); + } + public Builder SetValue(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto value) { + result.value_[index] = value; + return this; + } + public Builder SetValue(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder builderForValue) { + result.value_[index] = builderForValue.Build(); + return this; + } + public Builder AddValue(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto value) { + result.value_.Add(value); + return this; + } + public Builder AddValue(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder builderForValue) { + result.value_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeValue(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> values) { + base.AddRange(values, result.value_); + return this; + } + public Builder ClearValue() { + result.value_.Clear(); + return this; + } + + public bool HasOptions { + get { return result.HasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions Options { + get { return result.Options; } + set { SetOptions(value); } + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions value) { + result.hasOptions = true; + result.options_ = value; + return this; + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder builderForValue) { + result.hasOptions = true; + result.options_ = builderForValue.Build(); + return this; + } + public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions value) { + if (result.HasOptions && + result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance) { + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial(); + } else { + result.options_ = value; + } + result.hasOptions = true; + return this; + } + public Builder ClearOptions() { + result.hasOptions = false; + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance; + return this; + } + } + } + + public sealed partial class EnumValueDescriptorProto : pb::GeneratedMessage<EnumValueDescriptorProto, EnumValueDescriptorProto.Builder> { + private static readonly EnumValueDescriptorProto defaultInstance = new Builder().BuildPartial(); + public static EnumValueDescriptorProto DefaultInstance { + get { return defaultInstance; } + } + + public override EnumValueDescriptorProto DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override EnumValueDescriptorProto ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueDescriptorProto__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<EnumValueDescriptorProto, EnumValueDescriptorProto.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueDescriptorProto__FieldAccessorTable; } + } + + private bool hasName; + private string name_ = ""; + public bool HasName { + get { return hasName; } + } + public string Name { + get { return name_; } + } + + private bool hasNumber; + private int number_ = 0; + public bool HasNumber { + get { return hasNumber; } + } + public int Number { + get { return number_; } + } + + private bool hasOptions; + private global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance; + public bool HasOptions { + get { return hasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions Options { + get { return options_; } + } + + public override bool IsInitialized { + get { + if (HasOptions) { + if (!Options.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasName) { + output.WriteString(1, Name); + } + if (HasNumber) { + output.WriteInt32(2, Number); + } + if (HasOptions) { + output.WriteMessage(3, Options); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasName) { + size += pb::CodedOutputStream.ComputeStringSize(1, Name); + } + if (HasNumber) { + size += pb::CodedOutputStream.ComputeInt32Size(2, Number); + } + if (HasOptions) { + size += pb::CodedOutputStream.ComputeMessageSize(3, Options); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static EnumValueDescriptorProto ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static EnumValueDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static EnumValueDescriptorProto ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static EnumValueDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static EnumValueDescriptorProto ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static EnumValueDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static EnumValueDescriptorProto ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static EnumValueDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(EnumValueDescriptorProto prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<EnumValueDescriptorProto, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + EnumValueDescriptorProto result = new EnumValueDescriptorProto(); + + protected override EnumValueDescriptorProto MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new EnumValueDescriptorProto(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return EnumValueDescriptorProto.Descriptor; } + } + + public override EnumValueDescriptorProto DefaultInstanceForType { + get { return EnumValueDescriptorProto.DefaultInstance; } + } + + public override EnumValueDescriptorProto BuildPartial() { + EnumValueDescriptorProto returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is EnumValueDescriptorProto) { + return MergeFrom((EnumValueDescriptorProto) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(EnumValueDescriptorProto other) { + if (other == EnumValueDescriptorProto.DefaultInstance) return this; + if (other.HasName) { + Name = other.Name; + } + if (other.HasNumber) { + Number = other.Number; + } + if (other.HasOptions) { + MergeOptions(other.Options); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + Name = input.ReadString(); + break; + } + case 16: { + Number = input.ReadInt32(); + break; + } + case 26: { + global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder(); + if (HasOptions) { + subBuilder.MergeFrom(Options); + } + input.ReadMessage(subBuilder, extensionRegistry); + Options = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasName { + get { return result.HasName; } + } + public string Name { + get { return result.Name; } + set { SetName(value); } + } + public Builder SetName(string value) { + result.hasName = true; + result.name_ = value; + return this; + } + public Builder ClearName() { + result.hasName = false; + result.name_ = ""; + return this; + } + + public bool HasNumber { + get { return result.HasNumber; } + } + public int Number { + get { return result.Number; } + set { SetNumber(value); } + } + public Builder SetNumber(int value) { + result.hasNumber = true; + result.number_ = value; + return this; + } + public Builder ClearNumber() { + result.hasNumber = false; + result.number_ = 0; + return this; + } + + public bool HasOptions { + get { return result.HasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions Options { + get { return result.Options; } + set { SetOptions(value); } + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions value) { + result.hasOptions = true; + result.options_ = value; + return this; + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder builderForValue) { + result.hasOptions = true; + result.options_ = builderForValue.Build(); + return this; + } + public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions value) { + if (result.HasOptions && + result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance) { + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial(); + } else { + result.options_ = value; + } + result.hasOptions = true; + return this; + } + public Builder ClearOptions() { + result.hasOptions = false; + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance; + return this; + } + } + } + + public sealed partial class ServiceDescriptorProto : pb::GeneratedMessage<ServiceDescriptorProto, ServiceDescriptorProto.Builder> { + private static readonly ServiceDescriptorProto defaultInstance = new Builder().BuildPartial(); + public static ServiceDescriptorProto DefaultInstance { + get { return defaultInstance; } + } + + public override ServiceDescriptorProto DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ServiceDescriptorProto ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceDescriptorProto__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ServiceDescriptorProto, ServiceDescriptorProto.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceDescriptorProto__FieldAccessorTable; } + } + + private bool hasName; + private string name_ = ""; + public bool HasName { + get { return hasName; } + } + public string Name { + get { return name_; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> method_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> MethodList { + get { return method_; } + } + public int MethodCount { + get { return method_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto GetMethod(int index) { + return method_[index]; + } + + private bool hasOptions; + private global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance; + public bool HasOptions { + get { return hasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions Options { + get { return options_; } + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto element in MethodList) { + if (!element.IsInitialized) return false; + } + if (HasOptions) { + if (!Options.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasName) { + output.WriteString(1, Name); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto element in MethodList) { + output.WriteMessage(2, element); + } + if (HasOptions) { + output.WriteMessage(3, Options); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasName) { + size += pb::CodedOutputStream.ComputeStringSize(1, Name); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto element in MethodList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + if (HasOptions) { + size += pb::CodedOutputStream.ComputeMessageSize(3, Options); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ServiceDescriptorProto ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ServiceDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ServiceDescriptorProto ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ServiceDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ServiceDescriptorProto ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ServiceDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ServiceDescriptorProto ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ServiceDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ServiceDescriptorProto prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<ServiceDescriptorProto, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ServiceDescriptorProto result = new ServiceDescriptorProto(); + + protected override ServiceDescriptorProto MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ServiceDescriptorProto(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ServiceDescriptorProto.Descriptor; } + } + + public override ServiceDescriptorProto DefaultInstanceForType { + get { return ServiceDescriptorProto.DefaultInstance; } + } + + public override ServiceDescriptorProto BuildPartial() { + result.method_.MakeReadOnly(); + ServiceDescriptorProto returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ServiceDescriptorProto) { + return MergeFrom((ServiceDescriptorProto) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ServiceDescriptorProto other) { + if (other == ServiceDescriptorProto.DefaultInstance) return this; + if (other.HasName) { + Name = other.Name; + } + if (other.method_.Count != 0) { + base.AddRange(other.method_, result.method_); + } + if (other.HasOptions) { + MergeOptions(other.Options); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddMethod(subBuilder.BuildPartial()); + break; + } + case 26: { + global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder(); + if (HasOptions) { + subBuilder.MergeFrom(Options); + } + input.ReadMessage(subBuilder, extensionRegistry); + Options = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasName { + get { return result.HasName; } + } + public string Name { + get { return result.Name; } + set { SetName(value); } + } + public Builder SetName(string value) { + result.hasName = true; + result.name_ = value; + return this; + } + public Builder ClearName() { + result.hasName = false; + result.name_ = ""; + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> MethodList { + get { return result.method_; } + } + public int MethodCount { + get { return result.MethodCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto GetMethod(int index) { + return result.GetMethod(index); + } + public Builder SetMethod(int index, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto value) { + result.method_[index] = value; + return this; + } + public Builder SetMethod(int index, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder builderForValue) { + result.method_[index] = builderForValue.Build(); + return this; + } + public Builder AddMethod(global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto value) { + result.method_.Add(value); + return this; + } + public Builder AddMethod(global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder builderForValue) { + result.method_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeMethod(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> values) { + base.AddRange(values, result.method_); + return this; + } + public Builder ClearMethod() { + result.method_.Clear(); + return this; + } + + public bool HasOptions { + get { return result.HasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions Options { + get { return result.Options; } + set { SetOptions(value); } + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions value) { + result.hasOptions = true; + result.options_ = value; + return this; + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder builderForValue) { + result.hasOptions = true; + result.options_ = builderForValue.Build(); + return this; + } + public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions value) { + if (result.HasOptions && + result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance) { + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial(); + } else { + result.options_ = value; + } + result.hasOptions = true; + return this; + } + public Builder ClearOptions() { + result.hasOptions = false; + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance; + return this; + } + } + } + + public sealed partial class MethodDescriptorProto : pb::GeneratedMessage<MethodDescriptorProto, MethodDescriptorProto.Builder> { + private static readonly MethodDescriptorProto defaultInstance = new Builder().BuildPartial(); + public static MethodDescriptorProto DefaultInstance { + get { return defaultInstance; } + } + + public override MethodDescriptorProto DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override MethodDescriptorProto ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodDescriptorProto__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<MethodDescriptorProto, MethodDescriptorProto.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodDescriptorProto__FieldAccessorTable; } + } + + private bool hasName; + private string name_ = ""; + public bool HasName { + get { return hasName; } + } + public string Name { + get { return name_; } + } + + private bool hasInputType; + private string inputType_ = ""; + public bool HasInputType { + get { return hasInputType; } + } + public string InputType { + get { return inputType_; } + } + + private bool hasOutputType; + private string outputType_ = ""; + public bool HasOutputType { + get { return hasOutputType; } + } + public string OutputType { + get { return outputType_; } + } + + private bool hasOptions; + private global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance; + public bool HasOptions { + get { return hasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions Options { + get { return options_; } + } + + public override bool IsInitialized { + get { + if (HasOptions) { + if (!Options.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasName) { + output.WriteString(1, Name); + } + if (HasInputType) { + output.WriteString(2, InputType); + } + if (HasOutputType) { + output.WriteString(3, OutputType); + } + if (HasOptions) { + output.WriteMessage(4, Options); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasName) { + size += pb::CodedOutputStream.ComputeStringSize(1, Name); + } + if (HasInputType) { + size += pb::CodedOutputStream.ComputeStringSize(2, InputType); + } + if (HasOutputType) { + size += pb::CodedOutputStream.ComputeStringSize(3, OutputType); + } + if (HasOptions) { + size += pb::CodedOutputStream.ComputeMessageSize(4, Options); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static MethodDescriptorProto ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MethodDescriptorProto ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MethodDescriptorProto ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MethodDescriptorProto ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MethodDescriptorProto ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MethodDescriptorProto ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static MethodDescriptorProto ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MethodDescriptorProto ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(MethodDescriptorProto prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<MethodDescriptorProto, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + MethodDescriptorProto result = new MethodDescriptorProto(); + + protected override MethodDescriptorProto MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new MethodDescriptorProto(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return MethodDescriptorProto.Descriptor; } + } + + public override MethodDescriptorProto DefaultInstanceForType { + get { return MethodDescriptorProto.DefaultInstance; } + } + + public override MethodDescriptorProto BuildPartial() { + MethodDescriptorProto returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is MethodDescriptorProto) { + return MergeFrom((MethodDescriptorProto) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(MethodDescriptorProto other) { + if (other == MethodDescriptorProto.DefaultInstance) return this; + if (other.HasName) { + Name = other.Name; + } + if (other.HasInputType) { + InputType = other.InputType; + } + if (other.HasOutputType) { + OutputType = other.OutputType; + } + if (other.HasOptions) { + MergeOptions(other.Options); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + Name = input.ReadString(); + break; + } + case 18: { + InputType = input.ReadString(); + break; + } + case 26: { + OutputType = input.ReadString(); + break; + } + case 34: { + global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder(); + if (HasOptions) { + subBuilder.MergeFrom(Options); + } + input.ReadMessage(subBuilder, extensionRegistry); + Options = subBuilder.BuildPartial(); + break; + } + } + } + } + + + public bool HasName { + get { return result.HasName; } + } + public string Name { + get { return result.Name; } + set { SetName(value); } + } + public Builder SetName(string value) { + result.hasName = true; + result.name_ = value; + return this; + } + public Builder ClearName() { + result.hasName = false; + result.name_ = ""; + return this; + } + + public bool HasInputType { + get { return result.HasInputType; } + } + public string InputType { + get { return result.InputType; } + set { SetInputType(value); } + } + public Builder SetInputType(string value) { + result.hasInputType = true; + result.inputType_ = value; + return this; + } + public Builder ClearInputType() { + result.hasInputType = false; + result.inputType_ = ""; + return this; + } + + public bool HasOutputType { + get { return result.HasOutputType; } + } + public string OutputType { + get { return result.OutputType; } + set { SetOutputType(value); } + } + public Builder SetOutputType(string value) { + result.hasOutputType = true; + result.outputType_ = value; + return this; + } + public Builder ClearOutputType() { + result.hasOutputType = false; + result.outputType_ = ""; + return this; + } + + public bool HasOptions { + get { return result.HasOptions; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions Options { + get { return result.Options; } + set { SetOptions(value); } + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions value) { + result.hasOptions = true; + result.options_ = value; + return this; + } + public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder builderForValue) { + result.hasOptions = true; + result.options_ = builderForValue.Build(); + return this; + } + public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions value) { + if (result.HasOptions && + result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance) { + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial(); + } else { + result.options_ = value; + } + result.hasOptions = true; + return this; + } + public Builder ClearOptions() { + result.hasOptions = false; + result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance; + return this; + } + } + } + + public sealed partial class FileOptions : pb::ExtendableMessage<FileOptions, FileOptions.Builder> { + private static readonly FileOptions defaultInstance = new Builder().BuildPartial(); + public static FileOptions DefaultInstance { + get { return defaultInstance; } + } + + public override FileOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override FileOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<FileOptions, FileOptions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileOptions__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum OptimizeMode { + SPEED = 1, + CODE_SIZE = 2, + } + + } + #endregion + + private bool hasJavaPackage; + private string javaPackage_ = ""; + public bool HasJavaPackage { + get { return hasJavaPackage; } + } + public string JavaPackage { + get { return javaPackage_; } + } + + private bool hasJavaOuterClassname; + private string javaOuterClassname_ = ""; + public bool HasJavaOuterClassname { + get { return hasJavaOuterClassname; } + } + public string JavaOuterClassname { + get { return javaOuterClassname_; } + } + + private bool hasJavaMultipleFiles; + private bool javaMultipleFiles_ = false; + public bool HasJavaMultipleFiles { + get { return hasJavaMultipleFiles; } + } + public bool JavaMultipleFiles { + get { return javaMultipleFiles_; } + } + + private bool hasOptimizeFor; + private global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode optimizeFor_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode.CODE_SIZE; + public bool HasOptimizeFor { + get { return hasOptimizeFor; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode OptimizeFor { + get { return optimizeFor_; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return uninterpretedOption_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return uninterpretedOption_[index]; + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + if (!element.IsInitialized) return false; + } + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<FileOptions, FileOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + if (HasJavaPackage) { + output.WriteString(1, JavaPackage); + } + if (HasJavaOuterClassname) { + output.WriteString(8, JavaOuterClassname); + } + if (HasOptimizeFor) { + output.WriteEnum(9, (int) OptimizeFor); + } + if (HasJavaMultipleFiles) { + output.WriteBool(10, JavaMultipleFiles); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + output.WriteMessage(999, element); + } + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasJavaPackage) { + size += pb::CodedOutputStream.ComputeStringSize(1, JavaPackage); + } + if (HasJavaOuterClassname) { + size += pb::CodedOutputStream.ComputeStringSize(8, JavaOuterClassname); + } + if (HasJavaMultipleFiles) { + size += pb::CodedOutputStream.ComputeBoolSize(10, JavaMultipleFiles); + } + if (HasOptimizeFor) { + size += pb::CodedOutputStream.ComputeEnumSize(9, (int) OptimizeFor); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + size += pb::CodedOutputStream.ComputeMessageSize(999, element); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static FileOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FileOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FileOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FileOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FileOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FileOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static FileOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FileOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(FileOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<FileOptions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + FileOptions result = new FileOptions(); + + protected override FileOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new FileOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return FileOptions.Descriptor; } + } + + public override FileOptions DefaultInstanceForType { + get { return FileOptions.DefaultInstance; } + } + + public override FileOptions BuildPartial() { + result.uninterpretedOption_.MakeReadOnly(); + FileOptions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is FileOptions) { + return MergeFrom((FileOptions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(FileOptions other) { + if (other == FileOptions.DefaultInstance) return this; + if (other.HasJavaPackage) { + JavaPackage = other.JavaPackage; + } + if (other.HasJavaOuterClassname) { + JavaOuterClassname = other.JavaOuterClassname; + } + if (other.HasJavaMultipleFiles) { + JavaMultipleFiles = other.JavaMultipleFiles; + } + if (other.HasOptimizeFor) { + OptimizeFor = other.OptimizeFor; + } + if (other.uninterpretedOption_.Count != 0) { + base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + JavaPackage = input.ReadString(); + break; + } + case 66: { + JavaOuterClassname = input.ReadString(); + break; + } + case 72: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode), rawValue)) { + unknownFields.MergeVarintField(9, (ulong) rawValue); + } else { + OptimizeFor = (global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode) rawValue; + } + break; + } + case 80: { + JavaMultipleFiles = input.ReadBool(); + break; + } + case 7994: { + global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddUninterpretedOption(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public bool HasJavaPackage { + get { return result.HasJavaPackage; } + } + public string JavaPackage { + get { return result.JavaPackage; } + set { SetJavaPackage(value); } + } + public Builder SetJavaPackage(string value) { + result.hasJavaPackage = true; + result.javaPackage_ = value; + return this; + } + public Builder ClearJavaPackage() { + result.hasJavaPackage = false; + result.javaPackage_ = ""; + return this; + } + + public bool HasJavaOuterClassname { + get { return result.HasJavaOuterClassname; } + } + public string JavaOuterClassname { + get { return result.JavaOuterClassname; } + set { SetJavaOuterClassname(value); } + } + public Builder SetJavaOuterClassname(string value) { + result.hasJavaOuterClassname = true; + result.javaOuterClassname_ = value; + return this; + } + public Builder ClearJavaOuterClassname() { + result.hasJavaOuterClassname = false; + result.javaOuterClassname_ = ""; + return this; + } + + public bool HasJavaMultipleFiles { + get { return result.HasJavaMultipleFiles; } + } + public bool JavaMultipleFiles { + get { return result.JavaMultipleFiles; } + set { SetJavaMultipleFiles(value); } + } + public Builder SetJavaMultipleFiles(bool value) { + result.hasJavaMultipleFiles = true; + result.javaMultipleFiles_ = value; + return this; + } + public Builder ClearJavaMultipleFiles() { + result.hasJavaMultipleFiles = false; + result.javaMultipleFiles_ = false; + return this; + } + + public bool HasOptimizeFor { + get { return result.HasOptimizeFor; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode OptimizeFor { + get { return result.OptimizeFor; } + set { SetOptimizeFor(value); } + } + public Builder SetOptimizeFor(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode value) { + result.hasOptimizeFor = true; + result.optimizeFor_ = value; + return this; + } + public Builder ClearOptimizeFor() { + result.hasOptimizeFor = false; + result.optimizeFor_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode.CODE_SIZE; + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return result.uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return result.UninterpretedOptionCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return result.GetUninterpretedOption(index); + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_[index] = value; + return this; + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_[index] = builderForValue.Build(); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_.Add(value); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) { + base.AddRange(values, result.uninterpretedOption_); + return this; + } + public Builder ClearUninterpretedOption() { + result.uninterpretedOption_.Clear(); + return this; + } + } + } + + public sealed partial class MessageOptions : pb::ExtendableMessage<MessageOptions, MessageOptions.Builder> { + private static readonly MessageOptions defaultInstance = new Builder().BuildPartial(); + public static MessageOptions DefaultInstance { + get { return defaultInstance; } + } + + public override MessageOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override MessageOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MessageOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<MessageOptions, MessageOptions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MessageOptions__FieldAccessorTable; } + } + + private bool hasMessageSetWireFormat; + private bool messageSetWireFormat_ = false; + public bool HasMessageSetWireFormat { + get { return hasMessageSetWireFormat; } + } + public bool MessageSetWireFormat { + get { return messageSetWireFormat_; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return uninterpretedOption_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return uninterpretedOption_[index]; + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + if (!element.IsInitialized) return false; + } + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<MessageOptions, MessageOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + if (HasMessageSetWireFormat) { + output.WriteBool(1, MessageSetWireFormat); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + output.WriteMessage(999, element); + } + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasMessageSetWireFormat) { + size += pb::CodedOutputStream.ComputeBoolSize(1, MessageSetWireFormat); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + size += pb::CodedOutputStream.ComputeMessageSize(999, element); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static MessageOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MessageOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MessageOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MessageOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MessageOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MessageOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static MessageOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MessageOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(MessageOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<MessageOptions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + MessageOptions result = new MessageOptions(); + + protected override MessageOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new MessageOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return MessageOptions.Descriptor; } + } + + public override MessageOptions DefaultInstanceForType { + get { return MessageOptions.DefaultInstance; } + } + + public override MessageOptions BuildPartial() { + result.uninterpretedOption_.MakeReadOnly(); + MessageOptions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is MessageOptions) { + return MergeFrom((MessageOptions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(MessageOptions other) { + if (other == MessageOptions.DefaultInstance) return this; + if (other.HasMessageSetWireFormat) { + MessageSetWireFormat = other.MessageSetWireFormat; + } + if (other.uninterpretedOption_.Count != 0) { + base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + MessageSetWireFormat = input.ReadBool(); + break; + } + case 7994: { + global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddUninterpretedOption(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public bool HasMessageSetWireFormat { + get { return result.HasMessageSetWireFormat; } + } + public bool MessageSetWireFormat { + get { return result.MessageSetWireFormat; } + set { SetMessageSetWireFormat(value); } + } + public Builder SetMessageSetWireFormat(bool value) { + result.hasMessageSetWireFormat = true; + result.messageSetWireFormat_ = value; + return this; + } + public Builder ClearMessageSetWireFormat() { + result.hasMessageSetWireFormat = false; + result.messageSetWireFormat_ = false; + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return result.uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return result.UninterpretedOptionCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return result.GetUninterpretedOption(index); + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_[index] = value; + return this; + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_[index] = builderForValue.Build(); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_.Add(value); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) { + base.AddRange(values, result.uninterpretedOption_); + return this; + } + public Builder ClearUninterpretedOption() { + result.uninterpretedOption_.Clear(); + return this; + } + } + } + + public sealed partial class FieldOptions : pb::ExtendableMessage<FieldOptions, FieldOptions.Builder> { + private static readonly FieldOptions defaultInstance = new Builder().BuildPartial(); + public static FieldOptions DefaultInstance { + get { return defaultInstance; } + } + + public override FieldOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override FieldOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FieldOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<FieldOptions, FieldOptions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FieldOptions__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public enum CType { + CORD = 1, + STRING_PIECE = 2, + } + + } + #endregion + + private bool hasCtype; + private global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType ctype_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType.CORD; + public bool HasCtype { + get { return hasCtype; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType Ctype { + get { return ctype_; } + } + + private bool hasExperimentalMapKey; + private string experimentalMapKey_ = ""; + public bool HasExperimentalMapKey { + get { return hasExperimentalMapKey; } + } + public string ExperimentalMapKey { + get { return experimentalMapKey_; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return uninterpretedOption_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return uninterpretedOption_[index]; + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + if (!element.IsInitialized) return false; + } + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<FieldOptions, FieldOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + if (HasCtype) { + output.WriteEnum(1, (int) Ctype); + } + if (HasExperimentalMapKey) { + output.WriteString(9, ExperimentalMapKey); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + output.WriteMessage(999, element); + } + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasCtype) { + size += pb::CodedOutputStream.ComputeEnumSize(1, (int) Ctype); + } + if (HasExperimentalMapKey) { + size += pb::CodedOutputStream.ComputeStringSize(9, ExperimentalMapKey); + } + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + size += pb::CodedOutputStream.ComputeMessageSize(999, element); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static FieldOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FieldOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FieldOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static FieldOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static FieldOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FieldOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static FieldOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static FieldOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(FieldOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<FieldOptions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + FieldOptions result = new FieldOptions(); + + protected override FieldOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new FieldOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return FieldOptions.Descriptor; } + } + + public override FieldOptions DefaultInstanceForType { + get { return FieldOptions.DefaultInstance; } + } + + public override FieldOptions BuildPartial() { + result.uninterpretedOption_.MakeReadOnly(); + FieldOptions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is FieldOptions) { + return MergeFrom((FieldOptions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(FieldOptions other) { + if (other == FieldOptions.DefaultInstance) return this; + if (other.HasCtype) { + Ctype = other.Ctype; + } + if (other.HasExperimentalMapKey) { + ExperimentalMapKey = other.ExperimentalMapKey; + } + if (other.uninterpretedOption_.Count != 0) { + base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 8: { + int rawValue = input.ReadEnum(); + if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType), rawValue)) { + unknownFields.MergeVarintField(1, (ulong) rawValue); + } else { + Ctype = (global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType) rawValue; + } + break; + } + case 74: { + ExperimentalMapKey = input.ReadString(); + break; + } + case 7994: { + global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddUninterpretedOption(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public bool HasCtype { + get { return result.HasCtype; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType Ctype { + get { return result.Ctype; } + set { SetCtype(value); } + } + public Builder SetCtype(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType value) { + result.hasCtype = true; + result.ctype_ = value; + return this; + } + public Builder ClearCtype() { + result.hasCtype = false; + result.ctype_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType.CORD; + return this; + } + + public bool HasExperimentalMapKey { + get { return result.HasExperimentalMapKey; } + } + public string ExperimentalMapKey { + get { return result.ExperimentalMapKey; } + set { SetExperimentalMapKey(value); } + } + public Builder SetExperimentalMapKey(string value) { + result.hasExperimentalMapKey = true; + result.experimentalMapKey_ = value; + return this; + } + public Builder ClearExperimentalMapKey() { + result.hasExperimentalMapKey = false; + result.experimentalMapKey_ = ""; + return this; + } + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return result.uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return result.UninterpretedOptionCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return result.GetUninterpretedOption(index); + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_[index] = value; + return this; + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_[index] = builderForValue.Build(); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_.Add(value); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) { + base.AddRange(values, result.uninterpretedOption_); + return this; + } + public Builder ClearUninterpretedOption() { + result.uninterpretedOption_.Clear(); + return this; + } + } + } + + public sealed partial class EnumOptions : pb::ExtendableMessage<EnumOptions, EnumOptions.Builder> { + private static readonly EnumOptions defaultInstance = new Builder().BuildPartial(); + public static EnumOptions DefaultInstance { + get { return defaultInstance; } + } + + public override EnumOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override EnumOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<EnumOptions, EnumOptions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumOptions__FieldAccessorTable; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return uninterpretedOption_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return uninterpretedOption_[index]; + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + if (!element.IsInitialized) return false; + } + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<EnumOptions, EnumOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + output.WriteMessage(999, element); + } + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + size += pb::CodedOutputStream.ComputeMessageSize(999, element); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static EnumOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static EnumOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static EnumOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static EnumOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static EnumOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static EnumOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static EnumOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static EnumOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(EnumOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<EnumOptions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + EnumOptions result = new EnumOptions(); + + protected override EnumOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new EnumOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return EnumOptions.Descriptor; } + } + + public override EnumOptions DefaultInstanceForType { + get { return EnumOptions.DefaultInstance; } + } + + public override EnumOptions BuildPartial() { + result.uninterpretedOption_.MakeReadOnly(); + EnumOptions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is EnumOptions) { + return MergeFrom((EnumOptions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(EnumOptions other) { + if (other == EnumOptions.DefaultInstance) return this; + if (other.uninterpretedOption_.Count != 0) { + base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 7994: { + global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddUninterpretedOption(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return result.uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return result.UninterpretedOptionCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return result.GetUninterpretedOption(index); + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_[index] = value; + return this; + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_[index] = builderForValue.Build(); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_.Add(value); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) { + base.AddRange(values, result.uninterpretedOption_); + return this; + } + public Builder ClearUninterpretedOption() { + result.uninterpretedOption_.Clear(); + return this; + } + } + } + + public sealed partial class EnumValueOptions : pb::ExtendableMessage<EnumValueOptions, EnumValueOptions.Builder> { + private static readonly EnumValueOptions defaultInstance = new Builder().BuildPartial(); + public static EnumValueOptions DefaultInstance { + get { return defaultInstance; } + } + + public override EnumValueOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override EnumValueOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<EnumValueOptions, EnumValueOptions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueOptions__FieldAccessorTable; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return uninterpretedOption_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return uninterpretedOption_[index]; + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + if (!element.IsInitialized) return false; + } + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<EnumValueOptions, EnumValueOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + output.WriteMessage(999, element); + } + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + size += pb::CodedOutputStream.ComputeMessageSize(999, element); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static EnumValueOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static EnumValueOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static EnumValueOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static EnumValueOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static EnumValueOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static EnumValueOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static EnumValueOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static EnumValueOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(EnumValueOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<EnumValueOptions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + EnumValueOptions result = new EnumValueOptions(); + + protected override EnumValueOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new EnumValueOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return EnumValueOptions.Descriptor; } + } + + public override EnumValueOptions DefaultInstanceForType { + get { return EnumValueOptions.DefaultInstance; } + } + + public override EnumValueOptions BuildPartial() { + result.uninterpretedOption_.MakeReadOnly(); + EnumValueOptions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is EnumValueOptions) { + return MergeFrom((EnumValueOptions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(EnumValueOptions other) { + if (other == EnumValueOptions.DefaultInstance) return this; + if (other.uninterpretedOption_.Count != 0) { + base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 7994: { + global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddUninterpretedOption(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return result.uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return result.UninterpretedOptionCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return result.GetUninterpretedOption(index); + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_[index] = value; + return this; + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_[index] = builderForValue.Build(); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_.Add(value); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) { + base.AddRange(values, result.uninterpretedOption_); + return this; + } + public Builder ClearUninterpretedOption() { + result.uninterpretedOption_.Clear(); + return this; + } + } + } + + public sealed partial class ServiceOptions : pb::ExtendableMessage<ServiceOptions, ServiceOptions.Builder> { + private static readonly ServiceOptions defaultInstance = new Builder().BuildPartial(); + public static ServiceOptions DefaultInstance { + get { return defaultInstance; } + } + + public override ServiceOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override ServiceOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<ServiceOptions, ServiceOptions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceOptions__FieldAccessorTable; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return uninterpretedOption_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return uninterpretedOption_[index]; + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + if (!element.IsInitialized) return false; + } + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<ServiceOptions, ServiceOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + output.WriteMessage(999, element); + } + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + size += pb::CodedOutputStream.ComputeMessageSize(999, element); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static ServiceOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ServiceOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ServiceOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static ServiceOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static ServiceOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ServiceOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static ServiceOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static ServiceOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(ServiceOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<ServiceOptions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + ServiceOptions result = new ServiceOptions(); + + protected override ServiceOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new ServiceOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return ServiceOptions.Descriptor; } + } + + public override ServiceOptions DefaultInstanceForType { + get { return ServiceOptions.DefaultInstance; } + } + + public override ServiceOptions BuildPartial() { + result.uninterpretedOption_.MakeReadOnly(); + ServiceOptions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is ServiceOptions) { + return MergeFrom((ServiceOptions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(ServiceOptions other) { + if (other == ServiceOptions.DefaultInstance) return this; + if (other.uninterpretedOption_.Count != 0) { + base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 7994: { + global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddUninterpretedOption(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return result.uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return result.UninterpretedOptionCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return result.GetUninterpretedOption(index); + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_[index] = value; + return this; + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_[index] = builderForValue.Build(); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_.Add(value); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) { + base.AddRange(values, result.uninterpretedOption_); + return this; + } + public Builder ClearUninterpretedOption() { + result.uninterpretedOption_.Clear(); + return this; + } + } + } + + public sealed partial class MethodOptions : pb::ExtendableMessage<MethodOptions, MethodOptions.Builder> { + private static readonly MethodOptions defaultInstance = new Builder().BuildPartial(); + public static MethodOptions DefaultInstance { + get { return defaultInstance; } + } + + public override MethodOptions DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override MethodOptions ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodOptions__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<MethodOptions, MethodOptions.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodOptions__FieldAccessorTable; } + } + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return uninterpretedOption_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return uninterpretedOption_[index]; + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + if (!element.IsInitialized) return false; + } + if (!ExtensionsAreInitialized) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + pb::ExtendableMessage<MethodOptions, MethodOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + output.WriteMessage(999, element); + } + extensionWriter.WriteUntil(536870912, output); + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption element in UninterpretedOptionList) { + size += pb::CodedOutputStream.ComputeMessageSize(999, element); + } + size += ExtensionsSerializedSize; + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static MethodOptions ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MethodOptions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MethodOptions ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static MethodOptions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static MethodOptions ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MethodOptions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static MethodOptions ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static MethodOptions ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(MethodOptions prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::ExtendableBuilder<MethodOptions, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + MethodOptions result = new MethodOptions(); + + protected override MethodOptions MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new MethodOptions(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return MethodOptions.Descriptor; } + } + + public override MethodOptions DefaultInstanceForType { + get { return MethodOptions.DefaultInstance; } + } + + public override MethodOptions BuildPartial() { + result.uninterpretedOption_.MakeReadOnly(); + MethodOptions returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is MethodOptions) { + return MergeFrom((MethodOptions) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(MethodOptions other) { + if (other == MethodOptions.DefaultInstance) return this; + if (other.uninterpretedOption_.Count != 0) { + base.AddRange(other.uninterpretedOption_, result.uninterpretedOption_); + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 7994: { + global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddUninterpretedOption(subBuilder.BuildPartial()); + break; + } + } + } + } + + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> UninterpretedOptionList { + get { return result.uninterpretedOption_; } + } + public int UninterpretedOptionCount { + get { return result.UninterpretedOptionCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption GetUninterpretedOption(int index) { + return result.GetUninterpretedOption(index); + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_[index] = value; + return this; + } + public Builder SetUninterpretedOption(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_[index] = builderForValue.Build(); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption value) { + result.uninterpretedOption_.Add(value); + return this; + } + public Builder AddUninterpretedOption(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Builder builderForValue) { + result.uninterpretedOption_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeUninterpretedOption(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption> values) { + base.AddRange(values, result.uninterpretedOption_); + return this; + } + public Builder ClearUninterpretedOption() { + result.uninterpretedOption_.Clear(); + return this; + } + } + } + + public sealed partial class UninterpretedOption : pb::GeneratedMessage<UninterpretedOption, UninterpretedOption.Builder> { + private static readonly UninterpretedOption defaultInstance = new Builder().BuildPartial(); + public static UninterpretedOption DefaultInstance { + get { return defaultInstance; } + } + + public override UninterpretedOption DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override UninterpretedOption ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_UninterpretedOption__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<UninterpretedOption, UninterpretedOption.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_UninterpretedOption__FieldAccessorTable; } + } + + #region Nested types + public static class Types { + public sealed partial class NamePart : pb::GeneratedMessage<NamePart, NamePart.Builder> { + private static readonly NamePart defaultInstance = new Builder().BuildPartial(); + public static NamePart DefaultInstance { + get { return defaultInstance; } + } + + public override NamePart DefaultInstanceForType { + get { return defaultInstance; } + } + + protected override NamePart ThisMessage { + get { return this; } + } + + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_UninterpretedOption_NamePart__Descriptor; } + } + + protected override pb::FieldAccess.FieldAccessorTable<NamePart, NamePart.Builder> InternalFieldAccessors { + get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_UninterpretedOption_NamePart__FieldAccessorTable; } + } + + private bool hasNamePart; + private string namePart_ = ""; + public bool HasNamePart { + get { return hasNamePart; } + } + public string NamePart_ { + get { return namePart_; } + } + + private bool hasIsExtension; + private bool isExtension_ = false; + public bool HasIsExtension { + get { return hasIsExtension; } + } + public bool IsExtension { + get { return isExtension_; } + } + + public override bool IsInitialized { + get { + if (!hasNamePart) return false; + if (!hasIsExtension) return false; + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + if (HasNamePart) { + output.WriteString(1, NamePart_); + } + if (HasIsExtension) { + output.WriteBool(2, IsExtension); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (HasNamePart) { + size += pb::CodedOutputStream.ComputeStringSize(1, NamePart_); + } + if (HasIsExtension) { + size += pb::CodedOutputStream.ComputeBoolSize(2, IsExtension); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static NamePart ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NamePart ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NamePart ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static NamePart ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static NamePart ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NamePart ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static NamePart ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static NamePart ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(NamePart prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<NamePart, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + NamePart result = new NamePart(); + + protected override NamePart MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new NamePart(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return NamePart.Descriptor; } + } + + public override NamePart DefaultInstanceForType { + get { return NamePart.DefaultInstance; } + } + + public override NamePart BuildPartial() { + NamePart returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is NamePart) { + return MergeFrom((NamePart) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(NamePart other) { + if (other == NamePart.DefaultInstance) return this; + if (other.HasNamePart) { + NamePart_ = other.NamePart_; + } + if (other.HasIsExtension) { + IsExtension = other.IsExtension; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 10: { + NamePart_ = input.ReadString(); + break; + } + case 16: { + IsExtension = input.ReadBool(); + break; + } + } + } + } + + + public bool HasNamePart { + get { return result.HasNamePart; } + } + public string NamePart_ { + get { return result.NamePart_; } + set { SetNamePart(value); } + } + public Builder SetNamePart(string value) { + result.hasNamePart = true; + result.namePart_ = value; + return this; + } + public Builder ClearNamePart() { + result.hasNamePart = false; + result.namePart_ = ""; + return this; + } + + public bool HasIsExtension { + get { return result.HasIsExtension; } + } + public bool IsExtension { + get { return result.IsExtension; } + set { SetIsExtension(value); } + } + public Builder SetIsExtension(bool value) { + result.hasIsExtension = true; + result.isExtension_ = value; + return this; + } + public Builder ClearIsExtension() { + result.hasIsExtension = false; + result.isExtension_ = false; + return this; + } + } + } + + } + #endregion + + private pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart> name_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart>(); + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart> NameList { + get { return name_; } + } + public int NameCount { + get { return name_.Count; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart GetName(int index) { + return name_[index]; + } + + private bool hasIdentifierValue; + private string identifierValue_ = ""; + public bool HasIdentifierValue { + get { return hasIdentifierValue; } + } + public string IdentifierValue { + get { return identifierValue_; } + } + + private bool hasPositiveIntValue; + private ulong positiveIntValue_ = 0UL; + public bool HasPositiveIntValue { + get { return hasPositiveIntValue; } + } + public ulong PositiveIntValue { + get { return positiveIntValue_; } + } + + private bool hasNegativeIntValue; + private long negativeIntValue_ = 0L; + public bool HasNegativeIntValue { + get { return hasNegativeIntValue; } + } + public long NegativeIntValue { + get { return negativeIntValue_; } + } + + private bool hasDoubleValue; + private double doubleValue_ = 0D; + public bool HasDoubleValue { + get { return hasDoubleValue; } + } + public double DoubleValue { + get { return doubleValue_; } + } + + private bool hasStringValue; + private pb::ByteString stringValue_ = pb::ByteString.Empty; + public bool HasStringValue { + get { return hasStringValue; } + } + public pb::ByteString StringValue { + get { return stringValue_; } + } + + public override bool IsInitialized { + get { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart element in NameList) { + if (!element.IsInitialized) return false; + } + return true; + } + } + + public override void WriteTo(pb::CodedOutputStream output) { + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart element in NameList) { + output.WriteMessage(2, element); + } + if (HasIdentifierValue) { + output.WriteString(3, IdentifierValue); + } + if (HasPositiveIntValue) { + output.WriteUInt64(4, PositiveIntValue); + } + if (HasNegativeIntValue) { + output.WriteInt64(5, NegativeIntValue); + } + if (HasDoubleValue) { + output.WriteDouble(6, DoubleValue); + } + if (HasStringValue) { + output.WriteBytes(7, StringValue); + } + UnknownFields.WriteTo(output); + } + + private int memoizedSerializedSize = -1; + public override int SerializedSize { + get { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + foreach (global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart element in NameList) { + size += pb::CodedOutputStream.ComputeMessageSize(2, element); + } + if (HasIdentifierValue) { + size += pb::CodedOutputStream.ComputeStringSize(3, IdentifierValue); + } + if (HasPositiveIntValue) { + size += pb::CodedOutputStream.ComputeUInt64Size(4, PositiveIntValue); + } + if (HasNegativeIntValue) { + size += pb::CodedOutputStream.ComputeInt64Size(5, NegativeIntValue); + } + if (HasDoubleValue) { + size += pb::CodedOutputStream.ComputeDoubleSize(6, DoubleValue); + } + if (HasStringValue) { + size += pb::CodedOutputStream.ComputeBytesSize(7, StringValue); + } + size += UnknownFields.SerializedSize; + memoizedSerializedSize = size; + return size; + } + } + + public static UninterpretedOption ParseFrom(pb::ByteString data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static UninterpretedOption ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static UninterpretedOption ParseFrom(byte[] data) { + return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed(); + } + public static UninterpretedOption ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed(); + } + public static UninterpretedOption ParseFrom(global::System.IO.Stream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static UninterpretedOption ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static UninterpretedOption ParseFrom(pb::CodedInputStream input) { + return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed(); + } + public static UninterpretedOption ParseFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) { + return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed(); + } + public static Builder CreateBuilder() { return new Builder(); } + public override Builder CreateBuilderForType() { return new Builder(); } + public static Builder CreateBuilder(UninterpretedOption prototype) { + return (Builder) new Builder().MergeFrom(prototype); + } + + public sealed partial class Builder : pb::GeneratedBuilder<UninterpretedOption, Builder> { + protected override Builder ThisBuilder { + get { return this; } + } + public Builder() {} + + UninterpretedOption result = new UninterpretedOption(); + + protected override UninterpretedOption MessageBeingBuilt { + get { return result; } + } + + public override Builder Clear() { + result = new UninterpretedOption(); + return this; + } + + public override Builder Clone() { + return new Builder().MergeFrom(result); + } + + public override pbd::MessageDescriptor DescriptorForType { + get { return UninterpretedOption.Descriptor; } + } + + public override UninterpretedOption DefaultInstanceForType { + get { return UninterpretedOption.DefaultInstance; } + } + + public override UninterpretedOption BuildPartial() { + result.name_.MakeReadOnly(); + UninterpretedOption returnMe = result; + result = null; + return returnMe; + } + + public override Builder MergeFrom(pb::IMessage other) { + if (other is UninterpretedOption) { + return MergeFrom((UninterpretedOption) other); + } else { + base.MergeFrom(other); + return this; + } + } + + public override Builder MergeFrom(UninterpretedOption other) { + if (other == UninterpretedOption.DefaultInstance) return this; + if (other.name_.Count != 0) { + base.AddRange(other.name_, result.name_); + } + if (other.HasIdentifierValue) { + IdentifierValue = other.IdentifierValue; + } + if (other.HasPositiveIntValue) { + PositiveIntValue = other.PositiveIntValue; + } + if (other.HasNegativeIntValue) { + NegativeIntValue = other.NegativeIntValue; + } + if (other.HasDoubleValue) { + DoubleValue = other.DoubleValue; + } + if (other.HasStringValue) { + StringValue = other.StringValue; + } + 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 = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields); + while (true) { + uint tag = input.ReadTag(); + switch (tag) { + case 0: { + this.UnknownFields = unknownFields.Build(); + return this; + } + default: { + if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag)) { + this.UnknownFields = unknownFields.Build(); + return this; + } + break; + } + case 18: { + global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.CreateBuilder(); + input.ReadMessage(subBuilder, extensionRegistry); + AddName(subBuilder.BuildPartial()); + break; + } + case 26: { + IdentifierValue = input.ReadString(); + break; + } + case 32: { + PositiveIntValue = input.ReadUInt64(); + break; + } + case 40: { + NegativeIntValue = input.ReadInt64(); + break; + } + case 49: { + DoubleValue = input.ReadDouble(); + break; + } + case 58: { + StringValue = input.ReadBytes(); + break; + } + } + } + } + + + public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart> NameList { + get { return result.name_; } + } + public int NameCount { + get { return result.NameCount; } + } + public global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart GetName(int index) { + return result.GetName(index); + } + public Builder SetName(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart value) { + result.name_[index] = value; + return this; + } + public Builder SetName(int index, global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder builderForValue) { + result.name_[index] = builderForValue.Build(); + return this; + } + public Builder AddName(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart value) { + result.name_.Add(value); + return this; + } + public Builder AddName(global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart.Builder builderForValue) { + result.name_.Add(builderForValue.Build()); + return this; + } + public Builder AddRangeName(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.UninterpretedOption.Types.NamePart> values) { + base.AddRange(values, result.name_); + return this; + } + public Builder ClearName() { + result.name_.Clear(); + return this; + } + + public bool HasIdentifierValue { + get { return result.HasIdentifierValue; } + } + public string IdentifierValue { + get { return result.IdentifierValue; } + set { SetIdentifierValue(value); } + } + public Builder SetIdentifierValue(string value) { + result.hasIdentifierValue = true; + result.identifierValue_ = value; + return this; + } + public Builder ClearIdentifierValue() { + result.hasIdentifierValue = false; + result.identifierValue_ = ""; + return this; + } + + public bool HasPositiveIntValue { + get { return result.HasPositiveIntValue; } + } + public ulong PositiveIntValue { + get { return result.PositiveIntValue; } + set { SetPositiveIntValue(value); } + } + public Builder SetPositiveIntValue(ulong value) { + result.hasPositiveIntValue = true; + result.positiveIntValue_ = value; + return this; + } + public Builder ClearPositiveIntValue() { + result.hasPositiveIntValue = false; + result.positiveIntValue_ = 0UL; + return this; + } + + public bool HasNegativeIntValue { + get { return result.HasNegativeIntValue; } + } + public long NegativeIntValue { + get { return result.NegativeIntValue; } + set { SetNegativeIntValue(value); } + } + public Builder SetNegativeIntValue(long value) { + result.hasNegativeIntValue = true; + result.negativeIntValue_ = value; + return this; + } + public Builder ClearNegativeIntValue() { + result.hasNegativeIntValue = false; + result.negativeIntValue_ = 0L; + return this; + } + + public bool HasDoubleValue { + get { return result.HasDoubleValue; } + } + public double DoubleValue { + get { return result.DoubleValue; } + set { SetDoubleValue(value); } + } + public Builder SetDoubleValue(double value) { + result.hasDoubleValue = true; + result.doubleValue_ = value; + return this; + } + public Builder ClearDoubleValue() { + result.hasDoubleValue = false; + result.doubleValue_ = 0D; + return this; + } + + public bool HasStringValue { + get { return result.HasStringValue; } + } + public pb::ByteString StringValue { + get { return result.StringValue; } + set { SetStringValue(value); } + } + public Builder SetStringValue(pb::ByteString value) { + result.hasStringValue = true; + result.stringValue_ = value; + return this; + } + public Builder ClearStringValue() { + result.hasStringValue = false; + result.stringValue_ = pb::ByteString.Empty; + return this; + } + } + } + + #endregion + +} diff --git a/src/ProtocolBuffers/DescriptorProtos/IDescriptorProto.cs b/src/ProtocolBuffers/DescriptorProtos/IDescriptorProto.cs new file mode 100644 index 00000000..1b9f1dc3 --- /dev/null +++ b/src/ProtocolBuffers/DescriptorProtos/IDescriptorProto.cs @@ -0,0 +1,36 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +namespace Google.ProtocolBuffers.DescriptorProtos { + + /// <summary> + /// Interface implemented by all DescriptorProtos. The generator doesn't + /// emit the interface implementation claim, so PartialClasses.cs contains + /// partial class declarations for each of them. + /// </summary> + /// <typeparam name="TOptions">The associated options protocol buffer type</typeparam> + public interface IDescriptorProto<TOptions> { + + /// <summary> + /// The brief name of the descriptor's target. + /// </summary> + string Name { get; } + + /// <summary> + /// The options for this descriptor. + /// </summary> + TOptions Options { get; } + } +} diff --git a/src/ProtocolBuffers/DescriptorProtos/PartialClasses.cs b/src/ProtocolBuffers/DescriptorProtos/PartialClasses.cs new file mode 100644 index 00000000..5f414fc2 --- /dev/null +++ b/src/ProtocolBuffers/DescriptorProtos/PartialClasses.cs @@ -0,0 +1,43 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// This file just contains partial classes for each of the +// autogenerated classes, so that they implement +// IDescriptorProto +namespace Google.ProtocolBuffers.DescriptorProtos { + + // TODO(jonskeet): Find a better way of fixing this. It's needed in order to + // cope with unknown fields during initialization. + public partial class DescriptorProtoFile { + private static readonly bool initialized = false; + + internal static bool Bootstrapping { + get { return !initialized; } + } + + static DescriptorProtoFile() { + initialized = true; + } + } + + public partial class DescriptorProto : IDescriptorProto<MessageOptions> { } + public partial class EnumDescriptorProto : IDescriptorProto<EnumOptions> { } + public partial class EnumValueDescriptorProto : IDescriptorProto<EnumValueOptions> { } + public partial class FieldDescriptorProto : IDescriptorProto<FieldOptions> { } + public partial class FileDescriptorProto : IDescriptorProto<FileOptions> { } + public partial class MethodDescriptorProto : IDescriptorProto<MethodOptions> { } + public partial class ServiceDescriptorProto : IDescriptorProto<ServiceOptions> { } +} diff --git a/src/ProtocolBuffers/Descriptors/DescriptorBase.cs b/src/ProtocolBuffers/Descriptors/DescriptorBase.cs new file mode 100644 index 00000000..0c1414ae --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/DescriptorBase.cs @@ -0,0 +1,83 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.Descriptors { + /// <summary> + /// Base class for nearly all descriptors, providing common functionality. + /// </summary> + /// <typeparam name="TProto">Type of the protocol buffer form of this descriptor</typeparam> + /// <typeparam name="TOptions">Type of the options protocol buffer for this descriptor</typeparam> + public abstract class DescriptorBase<TProto, TOptions> : IDescriptor<TProto> + where TProto : IMessage, IDescriptorProto<TOptions> { + + private readonly TProto proto; + private readonly FileDescriptor file; + private readonly string fullName; + + protected DescriptorBase(TProto proto, FileDescriptor file, string fullName) { + this.proto = proto; + this.file = file; + this.fullName = fullName; + } + + protected static string ComputeFullName(FileDescriptor file, MessageDescriptor parent, string name) { + if (parent != null) { + return parent.FullName + "." + name; + } + if (file.Package.Length > 0) { + return file.Package + "." + name; + } + return name; + } + + IMessage IDescriptor.Proto { + get { return proto; } + } + + /// <summary> + /// Returns the protocol buffer form of this descriptor + /// </summary> + public TProto Proto { + get { return proto; } + } + + public TOptions Options { + get { return proto.Options; } + } + + /// <summary> + /// The fully qualified name of the descriptor's target. + /// </summary> + public string FullName { + get { return fullName; } + } + + /// <summary> + /// The brief name of the descriptor's target. + /// </summary> + public string Name { + get { return proto.Name; } + } + + /// <value> + /// The file this descriptor was declared in. + /// </value> + public FileDescriptor File { + get { return file; } + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/DescriptorPool.cs b/src/ProtocolBuffers/Descriptors/DescriptorPool.cs new file mode 100644 index 00000000..19a5b6a7 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/DescriptorPool.cs @@ -0,0 +1,281 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections.Generic; +using System; +using System.Text; +using System.Text.RegularExpressions; + +namespace Google.ProtocolBuffers.Descriptors { + /// <summary> + /// Contains lookup tables containing all the descriptors defined in a particular file. + /// </summary> + internal sealed class DescriptorPool { + + private readonly IDictionary<string, IDescriptor> descriptorsByName = + new Dictionary<string, IDescriptor>(); + private readonly IDictionary<DescriptorIntPair, FieldDescriptor> fieldsByNumber = + new Dictionary<DescriptorIntPair, FieldDescriptor>(); + private readonly IDictionary<DescriptorIntPair, EnumValueDescriptor> enumValuesByNumber = + new Dictionary<DescriptorIntPair, EnumValueDescriptor>(); + private readonly DescriptorPool[] dependencies; + + internal DescriptorPool(FileDescriptor[] dependencyFiles) { + dependencies = new DescriptorPool[dependencyFiles.Length]; + for (int i = 0; i < dependencyFiles.Length; i++) { + dependencies[i] = dependencyFiles[i].DescriptorPool; + } + + foreach (FileDescriptor dependency in dependencyFiles) { + AddPackage(dependency.Package, dependency); + } + } + + /// <summary> + /// Finds a symbol of the given name within the pool. + /// </summary> + /// <typeparam name="T">The type of symbol to look for</typeparam> + /// <param name="fullName">Fully-qualified name to look up</param> + /// <returns>The symbol with the given name and type, + /// or null if the symbol doesn't exist or has the wrong type</returns> + internal T FindSymbol<T>(string fullName) where T : class, IDescriptor { + IDescriptor result; + descriptorsByName.TryGetValue(fullName, out result); + T descriptor = result as T; + if (descriptor != null) { + return descriptor; + } + + foreach (DescriptorPool dependency in dependencies) { + dependency.descriptorsByName.TryGetValue(fullName, out result); + descriptor = result as T; + if (descriptor != null) { + return descriptor; + } + } + + return null; + } + + /// <summary> + /// Adds a package to the symbol tables. If a package by the same name + /// already exists, that is fine, but if some other kind of symbol + /// exists under the same name, an exception is thrown. If the package + /// has multiple components, this also adds the parent package(s). + /// </summary> + internal void AddPackage(string fullName, FileDescriptor file) { + int dotpos = fullName.LastIndexOf('.'); + String name; + if (dotpos != -1) { + AddPackage(fullName.Substring(0, dotpos), file); + name = fullName.Substring(dotpos + 1); + } else { + name = fullName; + } + + IDescriptor old; + if (descriptorsByName.TryGetValue(fullName, out old)) { + if (!(old is PackageDescriptor)) { + throw new DescriptorValidationException(file, + "\"" + name + "\" is already defined (as something other than a " + + "package) in file \"" + old.File.Name + "\"."); + } + } + // TODO(jonskeet): Check issue 25 wrt the ordering of these parameters + descriptorsByName[fullName] = new PackageDescriptor(fullName, name, file); + } + + /// <summary> + /// Adds a symbol to the symbol table. + /// </summary> + /// <exception cref="DescriptorValidationException">The symbol already existed + /// in the symbol table.</exception> + internal void AddSymbol(IDescriptor descriptor) { + ValidateSymbolName(descriptor); + String fullName = descriptor.FullName; + + IDescriptor old; + if (descriptorsByName.TryGetValue(fullName, out old)) { + int dotPos = fullName.LastIndexOf('.'); + string message; + if (descriptor.File == old.File) { + if (dotPos == -1) { + message = "\"" + fullName + "\" is already defined."; + } else { + message = "\"" + fullName.Substring(dotPos + 1) + "\" is already defined in \"" + fullName.Substring(0, dotPos) + "\"."; + } + } else { + message = "\"" + fullName + "\" is already defined in file \"" + old.File.Name + "\"."; + } + throw new DescriptorValidationException(descriptor, message); + } + descriptorsByName[fullName] = descriptor; + } + + private static readonly Regex ValidationRegex = new Regex("^[_A-Za-z][_A-Za-z0-9]*$", RegexOptions.Compiled); + + /// <summary> + /// Verifies that the descriptor's name is valid (i.e. it contains + /// only letters, digits and underscores, and does not start with a digit). + /// </summary> + /// <param name="descriptor"></param> + private static void ValidateSymbolName(IDescriptor descriptor) { + if (descriptor.Name == "") { + throw new DescriptorValidationException(descriptor, "Missing name."); + } + if (!ValidationRegex.IsMatch(descriptor.Name)) { + throw new DescriptorValidationException(descriptor, + "\"" + descriptor.Name + "\" is not a valid identifier."); + } + } + + /// <summary> + /// Returns the field with the given number in the given descriptor, + /// or null if it can't be found. + /// </summary> + internal FieldDescriptor FindFieldByNumber(MessageDescriptor messageDescriptor, int number) { + FieldDescriptor ret; + fieldsByNumber.TryGetValue(new DescriptorIntPair(messageDescriptor, number), out ret); + return ret; + } + + internal EnumValueDescriptor FindEnumValueByNumber(EnumDescriptor enumDescriptor, int number) { + EnumValueDescriptor ret; + enumValuesByNumber.TryGetValue(new DescriptorIntPair(enumDescriptor, number), out ret); + return ret; + } + + /// <summary> + /// Adds a field to the fieldsByNumber table. + /// </summary> + /// <exception cref="DescriptorValidationException">A field with the same + /// containing type and number already exists.</exception> + internal void AddFieldByNumber(FieldDescriptor field) { + DescriptorIntPair key = new DescriptorIntPair(field.ContainingType, field.FieldNumber); + FieldDescriptor old; + if (fieldsByNumber.TryGetValue(key, out old)) { + throw new DescriptorValidationException(field, "Field number " + field.FieldNumber + + "has already been used in \"" + field.ContainingType.FullName + + "\" by field \"" + old.Name + "\"."); + } + fieldsByNumber[key] = field; + } + + /// <summary> + /// Adds an enum value to the enumValuesByNumber table. If an enum value + /// with the same type and number already exists, this method does nothing. + /// (This is allowed; the first value defined with the number takes precedence.) + /// </summary> + internal void AddEnumValueByNumber(EnumValueDescriptor enumValue) { + DescriptorIntPair key = new DescriptorIntPair(enumValue.EnumDescriptor, enumValue.Number); + if (!enumValuesByNumber.ContainsKey(key)) { + enumValuesByNumber[key] = enumValue; + } + } + + /// <summary> + /// Looks up a descriptor by name, relative to some other descriptor. + /// The name may be fully-qualified (with a leading '.'), partially-qualified, + /// or unqualified. C++-like name lookup semantics are used to search for the + /// matching descriptor. + /// </summary> + public IDescriptor LookupSymbol(string name, IDescriptor relativeTo) { + // TODO(jonskeet): This could be optimized in a number of ways. + + IDescriptor result; + if (name.StartsWith(".")) { + // Fully-qualified name. + result = FindSymbol<IDescriptor>(name.Substring(1)); + } else { + // If "name" is a compound identifier, we want to search for the + // first component of it, then search within it for the rest. + int firstPartLength = name.IndexOf('.'); + string firstPart = firstPartLength == -1 ? name : name.Substring(0, firstPartLength); + + // We will search each parent scope of "relativeTo" looking for the + // symbol. + StringBuilder scopeToTry = new StringBuilder(relativeTo.FullName); + + while (true) { + // Chop off the last component of the scope. + + // TODO(jonskeet): Make this more efficient. May not be worth using StringBuilder at all + int dotpos = scopeToTry.ToString().LastIndexOf("."); + if (dotpos == -1) { + result = FindSymbol<IDescriptor>(name); + break; + } else { + scopeToTry.Length = dotpos + 1; + + // Append firstPart and try to find. + scopeToTry.Append(firstPart); + result = FindSymbol<IDescriptor>(scopeToTry.ToString()); + + if (result != null) { + if (firstPartLength != -1) { + // We only found the first part of the symbol. Now look for + // the whole thing. If this fails, we *don't* want to keep + // searching parent scopes. + scopeToTry.Length = dotpos + 1; + scopeToTry.Append(name); + result = FindSymbol<IDescriptor>(scopeToTry.ToString()); + } + break; + } + + // Not found. Remove the name so we can try again. + scopeToTry.Length = dotpos; + } + } + } + + if (result == null) { + throw new DescriptorValidationException(relativeTo, "\"" + name + "\" is not defined."); + } else { + return result; + } + } + + /// <summary> + /// Struct used to hold the keys for the fieldByNumber table. + /// </summary> + struct DescriptorIntPair : IEquatable<DescriptorIntPair> { + + private readonly int number; + private readonly IDescriptor descriptor; + + internal DescriptorIntPair(IDescriptor descriptor, int number) { + this.number = number; + this.descriptor = descriptor; + } + + public bool Equals(DescriptorIntPair other) { + return descriptor == other.descriptor + && number == other.number; + } + + public override bool Equals(object obj) { + if (obj is DescriptorIntPair) { + return Equals((DescriptorIntPair)obj); + } + return false; + } + + public override int GetHashCode() { + return descriptor.GetHashCode() * ((1 << 16) - 1) + number; + } + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/DescriptorUtil.cs b/src/ProtocolBuffers/Descriptors/DescriptorUtil.cs new file mode 100644 index 00000000..c945616d --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/DescriptorUtil.cs @@ -0,0 +1,43 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections.Generic; +using Google.ProtocolBuffers.Collections; + +namespace Google.ProtocolBuffers.Descriptors { + /// <summary> + /// Internal class containing utility methods when working with descriptors. + /// </summary> + internal static class DescriptorUtil { + /// <summary> + /// Equivalent to Func[TInput, int, TOutput] but usable in .NET 2.0. Only used to convert + /// arrays. + /// </summary> + internal delegate TOutput IndexedConverter<TInput, TOutput>(TInput element, int index); + + /// <summary> + /// Converts the given array into a read-only list, applying the specified conversion to + /// each input element. + /// </summary> + internal static IList<TOutput> ConvertAndMakeReadOnly<TInput, TOutput>(IList<TInput> input, + IndexedConverter<TInput, TOutput> converter) { + TOutput[] array = new TOutput[input.Count]; + for (int i = 0; i < array.Length; i++) { + array[i] = converter(input[i], i); + } + return Lists<TOutput>.AsReadOnly(array); + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/DescriptorValidationException.cs b/src/ProtocolBuffers/Descriptors/DescriptorValidationException.cs new file mode 100644 index 00000000..62c723f3 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/DescriptorValidationException.cs @@ -0,0 +1,70 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; + +namespace Google.ProtocolBuffers.Descriptors { + /// <summary> + /// Thrown when building descriptors fails because the source DescriptorProtos + /// are not valid. + /// </summary> + public sealed class DescriptorValidationException : Exception { + + private readonly String name; + private readonly IMessage proto; + private readonly string description; + + /// <value> + /// The full name of the descriptor where the error occurred. + /// </value> + public String ProblemSymbolName { + get { return name; } + } + + /// <value> + /// The protocol message representation of the invalid descriptor. + /// </value> + public IMessage ProblemProto { + get { return proto; } + } + + /// <value> + /// A human-readable description of the error. (The Message property + /// is made up of the descriptor's name and this description.) + /// </value> + public string Description { + get { return description; } + } + + internal DescriptorValidationException(IDescriptor problemDescriptor, string description) : + base(problemDescriptor.FullName + ": " + description) { + + // Note that problemDescriptor may be partially uninitialized, so we + // don't want to expose it directly to the user. So, we only provide + // the name and the original proto. + name = problemDescriptor.FullName; + proto = problemDescriptor.Proto; + this.description = description; + } + + internal DescriptorValidationException(IDescriptor problemDescriptor, string description, Exception cause) : + base(problemDescriptor.FullName + ": " + description, cause) { + + name = problemDescriptor.FullName; + proto = problemDescriptor.Proto; + this.description = description; + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/EnumDescriptor.cs b/src/ProtocolBuffers/Descriptors/EnumDescriptor.cs new file mode 100644 index 00000000..576051ab --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/EnumDescriptor.cs @@ -0,0 +1,76 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections.Generic; +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.Descriptors { + + /// <summary> + /// Descriptor for an enum type in a .proto file. + /// </summary> + public sealed class EnumDescriptor : IndexedDescriptorBase<EnumDescriptorProto, EnumOptions> { + + private readonly MessageDescriptor containingType; + private readonly IList<EnumValueDescriptor> values; + + internal EnumDescriptor(EnumDescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int index) + : base(proto, file, ComputeFullName(file, parent, proto.Name), index) { + containingType = parent; + + if (proto.ValueCount == 0) { + // We cannot allow enums with no values because this would mean there + // would be no valid default value for fields of this type. + throw new DescriptorValidationException(this, "Enums must contain at least one value."); + } + + values = DescriptorUtil.ConvertAndMakeReadOnly(proto.ValueList, + (value, i) => new EnumValueDescriptor(value, file, this, i)); + + File.DescriptorPool.AddSymbol(this); + } + + /// <value> + /// If this is a nested type, get the outer descriptor, otherwise null. + /// </value> + public MessageDescriptor ContainingType { + get { return containingType; } + } + + /// <value> + /// An unmodifiable list of defined value descriptors for this enum. + /// </value> + public IList<EnumValueDescriptor> Values { + get { return values; } + } + + /// <summary> + /// Finds an enum value by number. If multiple enum values have the + /// same number, this returns the first defined value with that number. + /// </summary> + internal EnumValueDescriptor FindValueByNumber(int number) { + return File.DescriptorPool.FindEnumValueByNumber(this, number); + } + + /// <summary> + /// Finds an enum value by name. + /// </summary> + /// <param name="name">The unqualified name of the value (e.g. "FOO").</param> + /// <returns>The value's descriptor, or null if not found.</returns> + internal EnumValueDescriptor FindValueByName(string name) { + return File.DescriptorPool.FindSymbol<EnumValueDescriptor>(FullName + "." + name); + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/EnumValueDescriptor.cs b/src/ProtocolBuffers/Descriptors/EnumValueDescriptor.cs new file mode 100644 index 00000000..112a7fb6 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/EnumValueDescriptor.cs @@ -0,0 +1,43 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.Descriptors { + + /// <summary> + /// Descriptor for a single enum value within an enum in a .proto file. + /// </summary> + public sealed class EnumValueDescriptor : IndexedDescriptorBase<EnumValueDescriptorProto, EnumValueOptions> { + + private readonly EnumDescriptor enumDescriptor; + + internal EnumValueDescriptor(EnumValueDescriptorProto proto, FileDescriptor file, + EnumDescriptor parent, int index) + : base (proto, file, parent.FullName + "." + proto.Name, index) { + enumDescriptor = parent; + file.DescriptorPool.AddSymbol(this); + file.DescriptorPool.AddEnumValueByNumber(this); + } + + public int Number { + get { return Proto.Number; } + } + + public EnumDescriptor EnumDescriptor { + get { return enumDescriptor; } + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/FieldDescriptor.cs b/src/ProtocolBuffers/Descriptors/FieldDescriptor.cs new file mode 100644 index 00000000..0cd552e4 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/FieldDescriptor.cs @@ -0,0 +1,437 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.Reflection; +using Google.ProtocolBuffers.Collections; +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.Descriptors { + + /// <summary> + /// Descriptor for a field or extension within a message in a .proto file. + /// </summary> + public sealed class FieldDescriptor : IndexedDescriptorBase<FieldDescriptorProto, FieldOptions>, IComparable<FieldDescriptor> { + + private readonly MessageDescriptor extensionScope; + private EnumDescriptor enumType; + private MessageDescriptor messageType; + private MessageDescriptor containingType; + private object defaultValue; + private FieldType fieldType; + private MappedType mappedType; + + internal FieldDescriptor(FieldDescriptorProto proto, FileDescriptor file, + MessageDescriptor parent, int index, bool isExtension) + : base(proto, file, ComputeFullName(file, parent, proto.Name), index) { + + if (proto.HasType) { + fieldType = GetFieldTypeFromProtoType(proto.Type); + mappedType = FieldTypeToMappedTypeMap[fieldType]; + } + + if (FieldNumber <= 0) { + throw new DescriptorValidationException(this, + "Field numbers must be positive integers."); + } + + if (isExtension) { + if (!proto.HasExtendee) { + throw new DescriptorValidationException(this, + "FieldDescriptorProto.Extendee not set for extension field."); + } + containingType = null; // Will be filled in when cross-linking + if (parent != null) { + extensionScope = parent; + } else { + extensionScope = null; + } + } else { + if (proto.HasExtendee) { + throw new DescriptorValidationException(this, + "FieldDescriptorProto.Extendee set for non-extension field."); + } + containingType = parent; + extensionScope = null; + } + + file.DescriptorPool.AddSymbol(this); + } + + /// <summary> + /// Maps a field type as included in the .proto file to a FieldType. + /// </summary> + private static FieldType GetFieldTypeFromProtoType(FieldDescriptorProto.Types.Type type) { + switch (type) { + case FieldDescriptorProto.Types.Type.TYPE_DOUBLE: return FieldType.Double; + case FieldDescriptorProto.Types.Type.TYPE_FLOAT: return FieldType.Float; + case FieldDescriptorProto.Types.Type.TYPE_INT64: return FieldType.Int64; + case FieldDescriptorProto.Types.Type.TYPE_UINT64: return FieldType.UInt64; + case FieldDescriptorProto.Types.Type.TYPE_INT32: return FieldType.Int32; + case FieldDescriptorProto.Types.Type.TYPE_FIXED64: return FieldType.Fixed64; + case FieldDescriptorProto.Types.Type.TYPE_FIXED32: return FieldType.Fixed32; + case FieldDescriptorProto.Types.Type.TYPE_BOOL: return FieldType.Bool; + case FieldDescriptorProto.Types.Type.TYPE_STRING: return FieldType.String; + case FieldDescriptorProto.Types.Type.TYPE_GROUP: return FieldType.Group; + case FieldDescriptorProto.Types.Type.TYPE_MESSAGE: return FieldType.Message; + case FieldDescriptorProto.Types.Type.TYPE_BYTES: return FieldType.Bytes; + case FieldDescriptorProto.Types.Type.TYPE_UINT32: return FieldType.UInt32; + case FieldDescriptorProto.Types.Type.TYPE_ENUM: return FieldType.Enum; + case FieldDescriptorProto.Types.Type.TYPE_SFIXED32: return FieldType.SFixed32; + case FieldDescriptorProto.Types.Type.TYPE_SFIXED64: return FieldType.SFixed64; + case FieldDescriptorProto.Types.Type.TYPE_SINT32: return FieldType.SInt32; + case FieldDescriptorProto.Types.Type.TYPE_SINT64: return FieldType.SInt64; + default: + throw new ArgumentException("Invalid type specified"); + } + } + + /// <summary> + /// Returns the default value for a mapped type. + /// </summary> + private static object GetDefaultValueForMappedType(MappedType type) { + switch (type) { + case MappedType.Int32: return 0; + case MappedType.Int64: return (long) 0; + case MappedType.UInt32: return (uint) 0; + case MappedType.UInt64: return (ulong) 0; + case MappedType.Single: return (float) 0; + case MappedType.Double: return (double) 0; + case MappedType.Boolean: return false; + case MappedType.String: return ""; + case MappedType.ByteString: return ByteString.Empty; + case MappedType.Message: return null; + case MappedType.Enum: return null; + default: + throw new ArgumentException("Invalid type specified"); + } + } + + public bool IsRequired { + get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_REQUIRED; } + } + + public bool IsOptional { + get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_OPTIONAL; } + } + + public bool IsRepeated { + get { return Proto.Label == FieldDescriptorProto.Types.Label.LABEL_REPEATED; } + } + + /// <valule> + /// Indicates whether or not the field had an explicitly-defined default value. + /// </value> + public bool HasDefaultValue { + get { return Proto.HasDefaultValue; } + } + + /// <value> + /// The field's default value. Valid for all types except messages + /// and groups. For all other types, the object returned is of the + /// same class that would be returned by IMessage[this]. + /// For repeated fields this will always be an empty immutable list compatible with IList[object]. + /// For message fields it will always be null. For singular values, it will depend on the descriptor. + /// </value> + public object DefaultValue { + get { + if (MappedType == MappedType.Message) { + throw new InvalidOperationException("FieldDescriptor.DefaultValue called on an embedded message field."); + } + return defaultValue; + } + } + + /// <value> + /// Indicates whether or not this field is an extension. + /// </value> + public bool IsExtension { + get { return Proto.HasExtendee; } + } + + /* + * Get the field's containing type. For extensions, this is the type being + * extended, not the location where the extension was defined. See + * {@link #getExtensionScope()}. + */ + /// <summary> + /// Get the field's containing type. For extensions, this is the type being + /// extended, not the location where the extension was defined. See + /// <see cref="ExtensionScope" />. + /// </summary> + public MessageDescriptor ContainingType { + get { return containingType; } + } + + /// <summary> + /// For extensions defined nested within message types, gets + /// the outer type. Not valid for non-extension fields. + /// </summary> + /// <example> + /// <code> + /// message Foo { + /// extensions 1000 to max; + /// } + /// extend Foo { + /// optional int32 baz = 1234; + /// } + /// message Bar { + /// extend Foo { + /// optional int32 qux = 4321; + /// } + /// } + /// </code> + /// The containing type for both <c>baz</c> and <c>qux</c> is <c>Foo</c>. + /// However, the extension scope for <c>baz</c> is <c>null</c> while + /// the extension scope for <c>qux</c> is <c>Bar</c>. + /// </example> + public MessageDescriptor ExtensionScope { + get { + if (!IsExtension) { + throw new InvalidOperationException("This field is not an extension."); + } + return extensionScope; + } + } + + public MappedType MappedType { + get { return mappedType; } + } + + public FieldType FieldType { + get { return fieldType; } + } + + public int FieldNumber { + get { return Proto.Number; } + } + + /// <summary> + /// Compares this descriptor with another one, ordering in "canonical" order + /// which simply means ascending order by field number. <paramref name="other"/> + /// must be a field of the same type, i.e. the <see cref="ContainingType"/> of + /// both fields must be the same. + /// </summary> + public int CompareTo(FieldDescriptor other) { + if (other.containingType != containingType) { + throw new ArgumentException("FieldDescriptors can only be compared to other FieldDescriptors " + + "for fields of the same message type."); + } + return FieldNumber - other.FieldNumber; + } + + + /// <summary> + /// For enum fields, returns the field's type. + /// </summary> + public EnumDescriptor EnumType { + get { + if (MappedType != MappedType.Enum) { + throw new InvalidOperationException("EnumType is only valid for enum fields."); + } + return enumType; + } + } + + /// <summary> + /// For embedded message and group fields, returns the field's type. + /// </summary> + public MessageDescriptor MessageType { + get { + if (MappedType != MappedType.Message) { + throw new InvalidOperationException("MessageType is only valid for enum fields."); + } + return messageType; + } + } + + /// <summary> + /// Immutable mapping from field type to mapped type. Built using the attributes on + /// FieldType values. + /// </summary> + public static readonly IDictionary<FieldType, MappedType> FieldTypeToMappedTypeMap = MapFieldTypes(); + + private static IDictionary<FieldType, MappedType> MapFieldTypes() { + var map = new Dictionary<FieldType, MappedType>(); + foreach (FieldInfo field in typeof(FieldType).GetFields(BindingFlags.Static | BindingFlags.Public)) { + FieldType fieldType = (FieldType)field.GetValue(null); + FieldMappingAttribute mapping = (FieldMappingAttribute)field.GetCustomAttributes(typeof(FieldMappingAttribute), false)[0]; + map[fieldType] = mapping.MappedType; + } + return Dictionaries.AsReadOnly(map); + } + + /// <summary> + /// Look up and cross-link all field types etc. + /// </summary> + internal void CrossLink() { + if (Proto.HasExtendee) { + IDescriptor extendee = File.DescriptorPool.LookupSymbol(Proto.Extendee, this); + if (!(extendee is MessageDescriptor)) { + throw new DescriptorValidationException(this, "\"" + Proto.Extendee + "\" is not a message type."); + } + containingType = (MessageDescriptor) extendee; + + if (!containingType.IsExtensionNumber(FieldNumber)) { + throw new DescriptorValidationException(this, + "\"" + containingType.FullName + "\" does not declare " + FieldNumber + " as an extension number."); + } + } + + if (Proto.HasTypeName) { + IDescriptor typeDescriptor = + File.DescriptorPool.LookupSymbol(Proto.TypeName, this); + + if (!Proto.HasType) { + // Choose field type based on symbol. + if (typeDescriptor is MessageDescriptor) { + fieldType = FieldType.Message; + mappedType = MappedType.Message; + } else if (typeDescriptor is EnumDescriptor) { + fieldType = FieldType.Enum; + mappedType = MappedType.Enum; + } else { + throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not a type."); + } + } + + if (MappedType == MappedType.Message) { + if (!(typeDescriptor is MessageDescriptor)) { + throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not a message type."); + } + messageType = (MessageDescriptor) typeDescriptor; + + if (Proto.HasDefaultValue) { + throw new DescriptorValidationException(this, "Messages can't have default values."); + } + } else if (MappedType == Descriptors.MappedType.Enum) { + if (!(typeDescriptor is EnumDescriptor)) { + throw new DescriptorValidationException(this, "\"" + Proto.TypeName + "\" is not an enum type."); + } + enumType = (EnumDescriptor)typeDescriptor; + } else { + throw new DescriptorValidationException(this, "Field with primitive type has type_name."); + } + } else { + if (MappedType == MappedType.Message || MappedType == MappedType.Enum) { + throw new DescriptorValidationException(this, "Field with message or enum type missing type_name."); + } + } + + // We don't attempt to parse the default value until here because for + // enums we need the enum type's descriptor. + if (Proto.HasDefaultValue) { + if (IsRepeated) { + throw new DescriptorValidationException(this, "Repeated fields cannot have default values."); + } + + try { + switch (FieldType) { + case FieldType.Int32: + case FieldType.SInt32: + case FieldType.SFixed32: + defaultValue = TextFormat.ParseInt32(Proto.DefaultValue); + break; + case FieldType.UInt32: + case FieldType.Fixed32: + defaultValue = TextFormat.ParseUInt32(Proto.DefaultValue); + break; + case FieldType.Int64: + case FieldType.SInt64: + case FieldType.SFixed64: + defaultValue = TextFormat.ParseInt64(Proto.DefaultValue); + break; + case FieldType.UInt64: + case FieldType.Fixed64: + defaultValue = TextFormat.ParseUInt64(Proto.DefaultValue); + break; + case FieldType.Float: + defaultValue = float.Parse(Proto.DefaultValue); + break; + case FieldType.Double: + defaultValue = double.Parse(Proto.DefaultValue); + break; + case FieldType.Bool: + if (Proto.DefaultValue == "true") { + defaultValue = true; + } else if (Proto.DefaultValue == "false") { + defaultValue = false; + } else { + throw new FormatException("Boolean values must be \"true\" or \"false\""); + } + break; + case FieldType.String: + defaultValue = Proto.DefaultValue; + break; + case FieldType.Bytes: + try { + defaultValue = TextFormat.UnescapeBytes(Proto.DefaultValue); + } catch (FormatException e) { + throw new DescriptorValidationException(this, "Couldn't parse default value: " + e.Message); + } + break; + case FieldType.Enum: + defaultValue = enumType.FindValueByName(Proto.DefaultValue); + if (defaultValue == null) { + throw new DescriptorValidationException(this, "Unknown enum default value: \"" + Proto.DefaultValue + "\""); + } + break; + case FieldType.Message: + case FieldType.Group: + throw new DescriptorValidationException(this, "Message type had default value."); + } + } catch (FormatException e) { + DescriptorValidationException validationException = + new DescriptorValidationException(this, "Could not parse default value: \"" + Proto.DefaultValue + "\"", e); + throw validationException; + } + } else { + // Determine the default default for this field. + if (IsRepeated) { + defaultValue = Lists<object>.Empty; + } else { + switch (MappedType) { + case MappedType.Enum: + // We guarantee elsewhere that an enum type always has at least + // one possible value. + defaultValue = enumType.Values[0]; + break; + case MappedType.Message: + defaultValue = null; + break; + default: + defaultValue = GetDefaultValueForMappedType(MappedType); + break; + } + } + } + + if (!IsExtension) { + File.DescriptorPool.AddFieldByNumber(this); + } + + if (containingType != null && containingType.Options.MessageSetWireFormat) { + if (IsExtension) { + if (!IsOptional || FieldType != FieldType.Message) { + throw new DescriptorValidationException(this, "Extensions of MessageSets must be optional messages."); + } + } else { + throw new DescriptorValidationException(this, "MessageSets cannot have fields, only extensions."); + } + } + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs b/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs new file mode 100644 index 00000000..18f88a31 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/FieldMappingAttribute.cs @@ -0,0 +1,34 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; + +namespace Google.ProtocolBuffers.Descriptors { + + /// <summary> + /// Defined specifically for the <see cref="FieldType" /> enumeration, + /// this allows each field type to specify the mapped type and wire type. + /// </summary> + [AttributeUsage(AttributeTargets.Field)] + internal sealed class FieldMappingAttribute : Attribute { + internal FieldMappingAttribute(MappedType mappedType, WireFormat.WireType wireType) { + MappedType = mappedType; + WireType = wireType; + } + + internal MappedType MappedType { get; private set; } + internal WireFormat.WireType WireType { get; private set; } + } +} diff --git a/src/ProtocolBuffers/Descriptors/FieldType.cs b/src/ProtocolBuffers/Descriptors/FieldType.cs new file mode 100644 index 00000000..7c15c0cc --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/FieldType.cs @@ -0,0 +1,42 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +namespace Google.ProtocolBuffers.Descriptors { + /// <summary> + /// Enumeration of all the possible field types. The odd formatting is to make it very clear + /// which attribute applies to which value, while maintaining a compact format. + /// </summary> + public enum FieldType { + [FieldMapping(MappedType.Double, WireFormat.WireType.Fixed64)] Double, + [FieldMapping(MappedType.Single, WireFormat.WireType.Fixed32)] Float, + [FieldMapping(MappedType.Int64, WireFormat.WireType.Varint)] Int64, + [FieldMapping(MappedType.UInt64, WireFormat.WireType.Varint)] UInt64, + [FieldMapping(MappedType.Int32, WireFormat.WireType.Varint)] Int32, + [FieldMapping(MappedType.UInt64, WireFormat.WireType.Fixed64)] Fixed64, + [FieldMapping(MappedType.UInt32, WireFormat.WireType.Fixed32)] Fixed32, + [FieldMapping(MappedType.Boolean, WireFormat.WireType.Varint)] Bool, + [FieldMapping(MappedType.String, WireFormat.WireType.LengthDelimited)] String, + [FieldMapping(MappedType.Message, WireFormat.WireType.StartGroup)] Group, + [FieldMapping(MappedType.Message, WireFormat.WireType.LengthDelimited)] Message, + [FieldMapping(MappedType.ByteString, WireFormat.WireType.LengthDelimited)] Bytes, + [FieldMapping(MappedType.UInt32, WireFormat.WireType.Varint)] UInt32, + [FieldMapping(MappedType.Int32, WireFormat.WireType.Fixed32)] SFixed32, + [FieldMapping(MappedType.Int64, WireFormat.WireType.Fixed64)] SFixed64, + [FieldMapping(MappedType.Int32, WireFormat.WireType.Varint)] SInt32, + [FieldMapping(MappedType.Int64, WireFormat.WireType.Varint)] SInt64, + [FieldMapping(MappedType.Enum, WireFormat.WireType.Varint)] Enum + } +} diff --git a/src/ProtocolBuffers/Descriptors/FileDescriptor.cs b/src/ProtocolBuffers/Descriptors/FileDescriptor.cs new file mode 100644 index 00000000..abd54e76 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/FileDescriptor.cs @@ -0,0 +1,246 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.Descriptors { + + /// <summary> + /// Describes a .proto file, including everything defined within. + /// IDescriptor is implemented such that the File property returns this descriptor, + /// and the FullName is the same as the Name. + /// </summary> + public sealed class FileDescriptor : IDescriptor<FileDescriptorProto> { + + private readonly FileDescriptorProto proto; + private readonly IList<MessageDescriptor> messageTypes; + private readonly IList<EnumDescriptor> enumTypes; + private readonly IList<ServiceDescriptor> services; + private readonly IList<FieldDescriptor> extensions; + private readonly IList<FileDescriptor> dependencies; + private readonly DescriptorPool pool; + + private FileDescriptor(FileDescriptorProto proto, FileDescriptor[] dependencies, DescriptorPool pool) { + this.pool = pool; + this.proto = proto; + this.dependencies = new ReadOnlyCollection<FileDescriptor>((FileDescriptor[]) dependencies.Clone()); + + pool.AddPackage(Package, this); + + messageTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.MessageTypeList, + (message, index) => new MessageDescriptor(message, this, null, index)); + + enumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumTypeList, + (enumType, index) => new EnumDescriptor(enumType, this, null, index)); + + services = DescriptorUtil.ConvertAndMakeReadOnly(proto.ServiceList, + (service, index) => new ServiceDescriptor(service, this, index)); + + extensions = DescriptorUtil.ConvertAndMakeReadOnly(proto.ExtensionList, + (field, index) => new FieldDescriptor(field, this, null, index, true)); + } + + /// <value> + /// The descriptor in its protocol message representation. + /// </value> + public FileDescriptorProto Proto { + get { return proto; } + } + + /// <value> + /// The <see cref="FileOptions" /> defined in <c>descriptor.proto</c>. + /// </value> + public FileOptions Options { + get { return proto.Options; } + } + + /// <value> + /// The file name. + /// </value> + public string Name { + get { return proto.Name; } + } + + /// <summary> + /// The package as declared in the .proto file. This may or may not + /// be equivalent to the .NET namespace of the generated classes. + /// </summary> + public string Package { + get { return proto.Package; } + } + + /// <value> + /// Unmodifiable list of top-level message types declared in this file. + /// </value> + public IList<MessageDescriptor> MessageTypes { + get { return messageTypes; } + } + + /// <value> + /// Unmodifiable list of top-level enum types declared in this file. + /// </value> + public IList<EnumDescriptor> EnumTypes { + get { return enumTypes; } + } + + /// <value> + /// Unmodifiable list of top-level services declared in this file. + /// </value> + public IList<ServiceDescriptor> Services { + get { return services; } + } + + /// <value> + /// Unmodifiable list of top-level extensions declared in this file. + /// </value> + public IList<FieldDescriptor> Extensions { + get { return extensions; } + } + + /// <value> + /// Unmodifiable list of this file's dependencies (imports). + /// </value> + public IList<FileDescriptor> Dependencies { + get { return dependencies; } + } + + /// <value> + /// Implementation of IDescriptor.FullName - just returns the same as Name. + /// </value> + string IDescriptor.FullName { + get { return Name; } + } + + /// <value> + /// Implementation of IDescriptor.File - just returns this descriptor. + /// </value> + FileDescriptor IDescriptor.File { + get { return this; } + } + + /// <value> + /// Protocol buffer describing this descriptor. + /// </value> + IMessage IDescriptor.Proto { + get { return Proto; } + } + + /// <value> + /// Pool containing symbol descriptors. + /// </value> + internal DescriptorPool DescriptorPool { + get { return pool; } + } + + /// <summary> + /// Finds a type (message, enum, service or extension) in the file by name. Does not find nested types. + /// </summary> + /// <param name="name">The unqualified type name to look for.</param> + /// <typeparam name="T">The type of descriptor to look for (or ITypeDescriptor for any)</typeparam> + /// <returns>The type's descriptor, or null if not found.</returns> + public T FindTypeByName<T>(String name) + where T : class, IDescriptor { + // Don't allow looking up nested types. This will make optimization + // easier later. + if (name.IndexOf('.') != -1) { + return null; + } + if (Package.Length > 0) { + name = Package + "." + name; + } + T result = pool.FindSymbol<T>(name); + if (result != null && result.File == this) { + return result; + } + return null; + } + + /// <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> + /// <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> + public static FileDescriptor BuildFrom(FileDescriptorProto proto, FileDescriptor[] dependencies) { + // Building descriptors involves two steps: translating and linking. + // In the translation step (implemented by FileDescriptor's + // constructor), we build an object tree mirroring the + // FileDescriptorProto's tree and put all of the descriptors into the + // DescriptorPool's lookup tables. In the linking step, we look up all + // type references in the DescriptorPool, so that, for example, a + // FieldDescriptor for an embedded message contains a pointer directly + // to the Descriptor for that message's type. We also detect undefined + // types in the linking step. + if (dependencies == null) { + dependencies = new FileDescriptor[0]; + } + + 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.");*/ + } + } + + result.CrossLink(); + return result; + } + + private void CrossLink() { + foreach (MessageDescriptor message in messageTypes) { + message.CrossLink(); + } + + foreach (ServiceDescriptor service in services) { + service.CrossLink(); + } + + foreach (FieldDescriptor extension in extensions) { + extension.CrossLink(); + } + + foreach (MessageDescriptor message in messageTypes) { + message.CheckRequiredFields(); + } + } + + /// <summary> + /// This method is to be called by generated code only. It is equivalent + /// to BuilderFrom except that the FileDescriptorProto is encoded in + /// protocol buffer wire format. + /// </summary> + public static FileDescriptor InternalBuildGeneratedFileFrom(byte[] descriptorData, + FileDescriptor[] dependencies) { + FileDescriptorProto proto = FileDescriptorProto.ParseFrom(descriptorData); + return BuildFrom(proto, dependencies); + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/IDescriptor.cs b/src/ProtocolBuffers/Descriptors/IDescriptor.cs new file mode 100644 index 00000000..2143f39a --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/IDescriptor.cs @@ -0,0 +1,37 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +namespace Google.ProtocolBuffers.Descriptors { + + /// <summary> + /// The non-generic form of the IDescriptor interface. Useful for describing a general + /// descriptor. + /// </summary> + public interface IDescriptor { + string Name { get; } + string FullName { get; } + FileDescriptor File { get; } + IMessage Proto { get; } + } + + /// <summary> + /// Strongly-typed form of the IDescriptor interface. + /// </summary> + /// <typeparam name="TProto">Protocol buffer type underlying this descriptor type</typeparam> + public interface IDescriptor<TProto> : IDescriptor where TProto : IMessage { + new TProto Proto { get; } + } +} diff --git a/src/ProtocolBuffers/Descriptors/IndexedDescriptorBase.cs b/src/ProtocolBuffers/Descriptors/IndexedDescriptorBase.cs new file mode 100644 index 00000000..d04d40db --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/IndexedDescriptorBase.cs @@ -0,0 +1,45 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.Descriptors { + /// <summary> + /// Base class for descriptors which are also indexed. This is all of them other than + /// <see cref="FileDescriptor" />. + /// </summary> + public abstract class IndexedDescriptorBase<TProto, TOptions> : DescriptorBase<TProto, TOptions> + where TProto : IMessage<TProto>, IDescriptorProto<TOptions> { + + private readonly int index; + + protected IndexedDescriptorBase(TProto proto, FileDescriptor file, string fullName, int index) + : base(proto, file, fullName) { + this.index = index; + } + + /// <value> + /// The index of this descriptor within its parent descriptor. + /// </value> + /// <remarks> + /// This returns the index of this descriptor within its parent, for + /// this descriptor's type. (There can be duplicate values for different + /// types, e.g. one enum type with index 0 and one message type with index 0.) + /// </remarks> + public int Index { + get { return index; } + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/MappedType.cs b/src/ProtocolBuffers/Descriptors/MappedType.cs new file mode 100644 index 00000000..ca7a7b43 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/MappedType.cs @@ -0,0 +1,34 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +namespace Google.ProtocolBuffers.Descriptors { + /// <summary> + /// Type as it's mapped onto a .NET type. + /// </summary> + public enum MappedType { + Int32, + Int64, + UInt32, + UInt64, + Single, + Double, + Boolean, + String, + ByteString, + Message, + Enum + } +} diff --git a/src/ProtocolBuffers/Descriptors/MessageDescriptor.cs b/src/ProtocolBuffers/Descriptors/MessageDescriptor.cs new file mode 100644 index 00000000..f387a325 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/MessageDescriptor.cs @@ -0,0 +1,186 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections.Generic; +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.Descriptors { + + /// <summary> + /// Describes a message type. + /// </summary> + public sealed class MessageDescriptor : IndexedDescriptorBase<DescriptorProto, MessageOptions> { + + private readonly MessageDescriptor containingType; + private readonly IList<MessageDescriptor> nestedTypes; + private readonly IList<EnumDescriptor> enumTypes; + private readonly IList<FieldDescriptor> fields; + private readonly IList<FieldDescriptor> extensions; + private bool hasRequiredFields; + + internal MessageDescriptor(DescriptorProto proto, FileDescriptor file, MessageDescriptor parent, int typeIndex) + : base(proto, file, ComputeFullName(file, parent, proto.Name), typeIndex) { + containingType = parent; + + nestedTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.NestedTypeList, + (type, index) => new MessageDescriptor(type, file, this, index)); + + enumTypes = DescriptorUtil.ConvertAndMakeReadOnly(proto.EnumTypeList, + (type, index) => new EnumDescriptor(type, file, this, index)); + + fields = DescriptorUtil.ConvertAndMakeReadOnly(proto.FieldList, + (field, index) => new FieldDescriptor(field, file, this, index, false)); + + extensions = DescriptorUtil.ConvertAndMakeReadOnly(proto.ExtensionList, + (field, index) => new FieldDescriptor(field, file, this, index, true)); + + file.DescriptorPool.AddSymbol(this); + } + + /// <value> + /// If this is a nested type, get the outer descriptor, otherwise null. + /// </value> + public MessageDescriptor ContainingType { + get { return containingType; } + } + + /// <value> + /// An unmodifiable list of this message type's fields. + /// </value> + public IList<FieldDescriptor> Fields { + get { return fields; } + } + + /// <value> + /// An unmodifiable list of this message type's extensions. + /// </value> + public IList<FieldDescriptor> Extensions { + get { return extensions; } + } + + /// <value> + /// An unmodifiable list of this message type's nested types. + /// </value> + public IList<MessageDescriptor> NestedTypes { + get { return nestedTypes; } + } + + /// <value> + /// An unmodifiable list of this message type's enum types. + /// </value> + public IList<EnumDescriptor> EnumTypes { + get { return enumTypes; } + } + + /// <summary> + /// Returns a pre-computed result as to whether this message + /// has required fields. This includes optional fields which are + /// message types which in turn have required fields, and any + /// extension fields. + /// </summary> + internal bool HasRequiredFields { + get { return hasRequiredFields; } + } + + /// <summary> + /// Determines if the given field number is an extension. + /// </summary> + public bool IsExtensionNumber(int number) { + foreach (DescriptorProto.Types.ExtensionRange range in Proto.ExtensionRangeList) { + if (range.Start <= number && number < range.End) { + return true; + } + } + return false; + } + + /// <summary> + /// Finds a field by field number. + /// </summary> + /// <param name="number">The field number within this message type.</param> + /// <returns>The field's descriptor, or null if not found.</returns> + public FieldDescriptor FindFieldByNumber(int number) { + return File.DescriptorPool.FindFieldByNumber(this, number); + } + + /// <summary> + /// Finds a nested descriptor by name. The is valid for fields, nested + /// message types and enums. + /// </summary> + /// <param name="name">The unqualified name of the descriptor, e.g. "Foo"</param> + /// <returns>The descriptor, or null if not found.</returns> + public T FindDescriptor<T>(string name) + where T : class, IDescriptor { + return File.DescriptorPool.FindSymbol<T>(FullName + "." + name); + } + + /// <summary> + /// Looks up and cross-links all fields, nested types, and extensions. + /// </summary> + internal void CrossLink() { + foreach (MessageDescriptor message in nestedTypes) { + message.CrossLink(); + } + + foreach (FieldDescriptor field in fields) { + field.CrossLink(); + } + + foreach (FieldDescriptor extension in extensions) { + extension.CrossLink(); + } + } + + internal void CheckRequiredFields() { + IDictionary<MessageDescriptor, byte> alreadySeen = new Dictionary<MessageDescriptor, byte>(); + hasRequiredFields = CheckRequiredFields(alreadySeen); + } + + private bool CheckRequiredFields(IDictionary<MessageDescriptor,byte> alreadySeen) { + + if (alreadySeen.ContainsKey(this)) { + // The type is already in the cache. This means that either: + // a. The type has no required fields. + // b. We are in the midst of checking if the type has required fields, + // somewhere up the stack. In this case, we know that if the type + // has any required fields, they'll be found when we return to it, + // and the whole call to HasRequiredFields() will return true. + // Therefore, we don't have to check if this type has required fields + // here. + return false; + } + alreadySeen[this] = 0; // Value is irrelevant; we want set semantics + + // If the type allows extensions, an extension with message type could contain + // required fields, so we have to be conservative and assume such an + // extension exists. + if (Proto.ExtensionRangeCount != 0) { + return true; + } + + foreach (FieldDescriptor field in Fields) { + if (field.IsRequired) { + return true; + } + if (field.MappedType == MappedType.Message) { + if (field.MessageType.CheckRequiredFields(alreadySeen)) { + return true; + } + } + } + return false; + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/MethodDescriptor.cs b/src/ProtocolBuffers/Descriptors/MethodDescriptor.cs new file mode 100644 index 00000000..13e6d141 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/MethodDescriptor.cs @@ -0,0 +1,70 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.Descriptors { + /// <summary> + /// Describes a single method in a service. + /// </summary> + public sealed class MethodDescriptor : IndexedDescriptorBase<MethodDescriptorProto, MethodOptions> { + + private readonly ServiceDescriptor service; + private MessageDescriptor inputType; + private MessageDescriptor outputType; + + /// <value> + /// The service this method belongs to. + /// </value> + public ServiceDescriptor Service { + get { return service; } + } + + /// <value> + /// The method's input type. + /// </value> + public MessageDescriptor InputType { + get { return inputType; } + } + + /// <value> + /// The method's input type. + /// </value> + public MessageDescriptor OutputType { + get { return outputType; } + } + + internal MethodDescriptor(MethodDescriptorProto proto, FileDescriptor file, + ServiceDescriptor parent, int index) + : base(proto, file, parent.FullName + "." + proto.Name, index) { + service = parent; + file.DescriptorPool.AddSymbol(this); + } + + internal void CrossLink() { + IDescriptor lookup = File.DescriptorPool.LookupSymbol(Proto.InputType, this); + if (!(lookup is MessageDescriptor)) { + throw new DescriptorValidationException(this, "\"" + Proto.InputType + "\" is not a message type."); + } + inputType = (MessageDescriptor) lookup; + + lookup = File.DescriptorPool.LookupSymbol(Proto.OutputType, this); + if (!(lookup is MessageDescriptor)) { + throw new DescriptorValidationException(this, "\"" + Proto.OutputType + "\" is not a message type."); + } + outputType = (MessageDescriptor) lookup; + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/PackageDescriptor.cs b/src/ProtocolBuffers/Descriptors/PackageDescriptor.cs new file mode 100644 index 00000000..9884c4a6 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/PackageDescriptor.cs @@ -0,0 +1,39 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace Google.ProtocolBuffers.Descriptors { + /// <summary> + /// Represents a package in the symbol table. We use PackageDescriptors + /// just as placeholders so that someone cannot define, say, a message type + /// that has the same name as an existing package. + /// </summary> + internal sealed class PackageDescriptor : IDescriptor<IMessage> { + + private readonly string name; + private readonly string fullName; + private readonly FileDescriptor file; + + internal PackageDescriptor(string name, string fullName, FileDescriptor file) { + this.file = file; + this.fullName = fullName; + this.name = name; + } + + public IMessage Proto { + get { return file.Proto; } + } + + public string Name { + get { return name; } + } + + public string FullName { + get { return fullName; } + } + + public FileDescriptor File { + get { return file; } + } + } +} diff --git a/src/ProtocolBuffers/Descriptors/ServiceDescriptor.cs b/src/ProtocolBuffers/Descriptors/ServiceDescriptor.cs new file mode 100644 index 00000000..cb152637 --- /dev/null +++ b/src/ProtocolBuffers/Descriptors/ServiceDescriptor.cs @@ -0,0 +1,60 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers.Descriptors { + + /// <summary> + /// Describes a service type. + /// </summary> + public sealed class ServiceDescriptor : IndexedDescriptorBase<ServiceDescriptorProto, ServiceOptions> { + + private readonly IList<MethodDescriptor> methods; + + public ServiceDescriptor(ServiceDescriptorProto proto, FileDescriptor file, int index) + : base(proto, file, ComputeFullName(file, null, proto.Name), index) { + + methods = DescriptorUtil.ConvertAndMakeReadOnly(proto.MethodList, + (method, i) => new MethodDescriptor(method, file, this, i)); + + file.DescriptorPool.AddSymbol(this); + } + + /// <value> + /// An unmodifiable list of methods in this service. + /// </value> + public IList<MethodDescriptor> Methods { + get { return methods; } + } + + /// <summary> + /// Finds a method by name. + /// </summary> + /// <param name="name">The unqualified name of the method (e.g. "Foo").</param> + /// <returns>The method's decsriptor, or null if not found.</returns> + public MethodDescriptor FindMethodByName(String name) { + return File.DescriptorPool.FindSymbol<MethodDescriptor>(FullName + "." + name); + } + + internal void CrossLink() { + foreach (MethodDescriptor method in methods) { + method.CrossLink(); + } + } + } +} diff --git a/src/ProtocolBuffers/DynamicMessage.cs b/src/ProtocolBuffers/DynamicMessage.cs new file mode 100644 index 00000000..c05a274b --- /dev/null +++ b/src/ProtocolBuffers/DynamicMessage.cs @@ -0,0 +1,414 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.IO; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// An implementation of IMessage that can represent arbitrary types, given a MessageaDescriptor. + /// </summary> + public sealed class DynamicMessage : AbstractMessage<DynamicMessage, DynamicMessage.Builder> { + + private readonly MessageDescriptor type; + private readonly FieldSet fields; + private readonly UnknownFieldSet unknownFields; + private int memoizedSize = -1; + + /// <summary> + /// Creates a DynamicMessage with the given FieldSet. + /// </summary> + /// <param name="type"></param> + /// <param name="fields"></param> + /// <param name="unknownFields"></param> + private DynamicMessage(MessageDescriptor type, FieldSet fields, UnknownFieldSet unknownFields) { + this.type = type; + this.fields = fields; + this.unknownFields = unknownFields; + } + + /// <summary> + /// Returns a DynamicMessage representing the default instance of the given type. + /// </summary> + /// <param name="type"></param> + /// <returns></returns> + public static DynamicMessage GetDefaultInstance(MessageDescriptor type) { + return new DynamicMessage(type, FieldSet.DefaultInstance, UnknownFieldSet.DefaultInstance); + } + + /// <summary> + /// Parses a message of the given type from the given stream. + /// </summary> + public static DynamicMessage ParseFrom(MessageDescriptor type, CodedInputStream input) { + Builder builder = CreateBuilder(type); + Builder dynamicBuilder = builder.MergeFrom(input); + return dynamicBuilder.BuildParsed(); + + } + + /// <summary> + /// Parse a message of the given type from the given stream and extension registry. + /// </summary> + /// <param name="type"></param> + /// <param name="input"></param> + /// <param name="extensionRegistry"></param> + /// <returns></returns> + public static DynamicMessage ParseFrom(MessageDescriptor type, CodedInputStream input, ExtensionRegistry extensionRegistry) { + Builder builder = CreateBuilder(type); + Builder dynamicBuilder = builder.MergeFrom(input, extensionRegistry); + return dynamicBuilder.BuildParsed(); + } + + /// <summary> + /// Parses a message of the given type from the given stream. + /// </summary> + public static DynamicMessage ParseFrom(MessageDescriptor type, Stream input) { + Builder builder = CreateBuilder(type); + Builder dynamicBuilder = builder.MergeFrom(input); + return dynamicBuilder.BuildParsed(); + } + + /// <summary> + /// Parse a message of the given type from the given stream and extension registry. + /// </summary> + /// <param name="type"></param> + /// <param name="input"></param> + /// <param name="extensionRegistry"></param> + /// <returns></returns> + public static DynamicMessage ParseFrom(MessageDescriptor type, Stream input, ExtensionRegistry extensionRegistry) { + Builder builder = CreateBuilder(type); + Builder dynamicBuilder = builder.MergeFrom(input, extensionRegistry); + return dynamicBuilder.BuildParsed(); + } + + /// <summary> + /// Parse <paramref name="data"/> as a message of the given type and return it. + /// </summary> + public static DynamicMessage ParseFrom(MessageDescriptor type, ByteString data) { + Builder builder = CreateBuilder(type); + Builder dynamicBuilder = builder.MergeFrom(data); + return dynamicBuilder.BuildParsed(); + } + + /// <summary> + /// Parse <paramref name="data"/> as a message of the given type and return it. + /// </summary> + public static DynamicMessage ParseFrom(MessageDescriptor type, ByteString data, ExtensionRegistry extensionRegistry) { + Builder builder = CreateBuilder(type); + Builder dynamicBuilder = builder.MergeFrom(data, extensionRegistry); + return dynamicBuilder.BuildParsed(); + + } + + /// <summary> + /// Parse <paramref name="data"/> as a message of the given type and return it. + /// </summary> + public static DynamicMessage ParseFrom(MessageDescriptor type, byte[] data) { + Builder builder = CreateBuilder(type); + Builder dynamicBuilder = builder.MergeFrom(data); + return dynamicBuilder.BuildParsed(); + } + + /// <summary> + /// Parse <paramref name="data"/> as a message of the given type and return it. + /// </summary> + public static DynamicMessage ParseFrom(MessageDescriptor type, byte[] data, ExtensionRegistry extensionRegistry) { + Builder builder = CreateBuilder(type); + Builder dynamicBuilder = builder.MergeFrom(data, extensionRegistry); + return dynamicBuilder.BuildParsed(); + } + + /// <summary> + /// Constructs a builder for the given type. + /// </summary> + public static Builder CreateBuilder(MessageDescriptor type) { + return new Builder(type); + } + + /// <summary> + /// Constructs a builder for a message of the same type as <paramref name="prototype"/>, + /// and initializes it with the same contents. + /// </summary> + /// <param name="prototype"></param> + /// <returns></returns> + public static Builder CreateBuilder(IMessage prototype) { + return new Builder(prototype.DescriptorForType).MergeFrom(prototype); + } + + // ----------------------------------------------------------------- + // Implementation of IMessage interface. + + public override MessageDescriptor DescriptorForType { + get { return type; } + } + + public override DynamicMessage DefaultInstanceForType { + get { return GetDefaultInstance(type); } + } + + public override IDictionary<FieldDescriptor, object> AllFields { + get { return fields.AllFields; } + } + + public override bool HasField(FieldDescriptor field) { + VerifyContainingType(field); + return fields.HasField(field); + } + + public override object this[FieldDescriptor field] { + get { + VerifyContainingType(field); + object result = fields[field]; + if (result == null) { + result = GetDefaultInstance(field.MessageType); + } + return result; + } + } + + public override int GetRepeatedFieldCount(FieldDescriptor field) { + VerifyContainingType(field); + return fields.GetRepeatedFieldCount(field); + } + + public override object this[FieldDescriptor field, int index] { + get { + VerifyContainingType(field); + return fields[field, index]; + } + } + + public override UnknownFieldSet UnknownFields { + get { return unknownFields; } + } + + public bool Initialized { + get { return fields.IsInitializedWithRespectTo(type); } + } + + public override void WriteTo(CodedOutputStream output) { + fields.WriteTo(output); + if (type.Options.MessageSetWireFormat) { + unknownFields.WriteAsMessageSetTo(output); + } else { + unknownFields.WriteTo(output); + } + } + + public override int SerializedSize { + get { + int size = memoizedSize; + if (size != -1) return size; + + size = fields.SerializedSize; + if (type.Options.MessageSetWireFormat) { + size += unknownFields.SerializedSizeAsMessageSet; + } else { + size += unknownFields.SerializedSize; + } + + memoizedSize = size; + return size; + } + } + + public override Builder CreateBuilderForType() { + return new Builder(type); + } + + /// <summary> + /// Verifies that the field is a field of this message. + /// </summary> + private void VerifyContainingType(FieldDescriptor field) { + if (field.ContainingType != type) { + throw new ArgumentException("FieldDescriptor does not match message type."); + } + } + + /// <summary> + /// Builder for dynamic messages. Instances are created with DynamicMessage.CreateBuilder. + /// </summary> + public sealed class Builder : AbstractBuilder<DynamicMessage, Builder> { + private readonly MessageDescriptor type; + private FieldSet fields; + private UnknownFieldSet unknownFields; + + internal Builder(MessageDescriptor type) { + this.type = type; + this.fields = FieldSet.CreateInstance(); + this.unknownFields = UnknownFieldSet.DefaultInstance; + } + + protected override Builder ThisBuilder { + get { return this; } + } + + public override Builder Clear() { + fields.Clear(); + return this; + } + + public override Builder MergeFrom(IMessage other) { + if (other.DescriptorForType != type) { + throw new ArgumentException("MergeFrom(IMessage) can only merge messages of the same type."); + } + fields.MergeFrom(other); + return this; + } + + public override Builder MergeFrom(DynamicMessage other) { + if (other.DescriptorForType != type) { + throw new ArgumentException("MergeFrom(IMessage) can only merge messages of the same type."); + } + fields.MergeFrom(other); + return this; + } + + public override DynamicMessage Build() { + if (!IsInitialized) { + throw new UninitializedMessageException(new DynamicMessage(type, fields, unknownFields)); + } + return BuildPartial(); + } + + /// <summary> + /// Helper for DynamicMessage.ParseFrom() methods to call. Throws + /// InvalidProtocolBufferException + /// </summary> + /// <returns></returns> + internal DynamicMessage BuildParsed() { + if (!IsInitialized) { + throw new UninitializedMessageException(new DynamicMessage(type, fields, unknownFields)).AsInvalidProtocolBufferException(); + } + return BuildPartial(); + } + + public override DynamicMessage BuildPartial() { + fields.MakeImmutable(); + DynamicMessage result = new DynamicMessage(type, fields, unknownFields); + fields = null; + unknownFields = null; + return result; + } + + public override Builder Clone() { + Builder result = new Builder(type); + result.fields.MergeFrom(fields); + return result; + } + + public override bool IsInitialized { + get { return fields.IsInitializedWithRespectTo(type); } + } + + public override Builder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry) { + UnknownFieldSet.Builder unknownFieldsBuilder = UnknownFieldSet.CreateBuilder(unknownFields); + unknownFieldsBuilder.MergeFrom(input, extensionRegistry, this); + unknownFields = unknownFieldsBuilder.Build(); + return this; + } + + public override MessageDescriptor DescriptorForType { + get { return type; } + } + + public override DynamicMessage DefaultInstanceForType { + get { return GetDefaultInstance(type); } + } + + public override IDictionary<FieldDescriptor, object> AllFields { + get { return fields.AllFields; } + } + + public override IBuilder CreateBuilderForField(FieldDescriptor field) { + VerifyContainingType(field); + if (field.MappedType != MappedType.Message) { + throw new ArgumentException("CreateBuilderForField is only valid for fields with message type."); + } + return new Builder(field.MessageType); + } + + public override bool HasField(FieldDescriptor field) { + VerifyContainingType(field); + return fields.HasField(field); + } + + public override object this[FieldDescriptor field, int index] { + get { + VerifyContainingType(field); + return fields[field, index]; + } + set { + VerifyContainingType(field); + fields[field, index] = value; + } + } + + public override object this[FieldDescriptor field] { + get { + VerifyContainingType(field); + object result = fields[field]; + if (result == null) { + result = GetDefaultInstance(field.MessageType); + } + return result; + } + set { + VerifyContainingType(field); + fields[field] = value; + } + } + + public override Builder ClearField(FieldDescriptor field) { + VerifyContainingType(field); + fields.ClearField(field); + return this; + } + + public override int GetRepeatedFieldCount(FieldDescriptor field) { + VerifyContainingType(field); + return fields.GetRepeatedFieldCount(field); + } + + public override Builder AddRepeatedField(FieldDescriptor field, object value) { + VerifyContainingType(field); + fields.AddRepeatedField(field, value); + return this; + } + + public override UnknownFieldSet UnknownFields { + get { + return unknownFields; + } + set { + unknownFields = value; + } + } + + /// <summary> + /// Verifies that the field is a field of this message. + /// </summary> + /// <param name="field"></param> + private void VerifyContainingType(FieldDescriptor field) { + if (field.ContainingType != type) { + throw new ArgumentException("FieldDescriptor does not match message type."); + } + } + } + } +} diff --git a/src/ProtocolBuffers/ExtendableBuilder.cs b/src/ProtocolBuffers/ExtendableBuilder.cs new file mode 100644 index 00000000..6970d7c3 --- /dev/null +++ b/src/ProtocolBuffers/ExtendableBuilder.cs @@ -0,0 +1,154 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + public abstract class ExtendableBuilder<TMessage, TBuilder> : GeneratedBuilder<TMessage, TBuilder> + where TMessage : ExtendableMessage<TMessage, TBuilder> + where TBuilder : GeneratedBuilder<TMessage, TBuilder> { + + protected ExtendableBuilder() {} + + /// <summary> + /// Checks if a singular extension is present + /// </summary> + public bool HasExtension<TExtension>(GeneratedExtensionBase<TExtension> extension) { + return MessageBeingBuilt.HasExtension(extension); + } + + /// <summary> + /// Returns the number of elements in a repeated extension. + /// </summary> + public int GetExtensionCount<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension) { + return MessageBeingBuilt.GetExtensionCount(extension); + } + + /// <summary> + /// Returns the value of an extension. + /// </summary> + public TExtension GetExtension<TExtension>(GeneratedExtensionBase<TExtension> extension) { + return MessageBeingBuilt.GetExtension(extension); + } + + /// <summary> + /// Returns one element of a repeated extension. + /// </summary> + public TExtension GetExtension<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension, int index) { + return MessageBeingBuilt.GetExtension(extension, index); + } + + /// <summary> + /// Sets the value of an extension. + /// </summary> + public TBuilder SetExtension<TExtension>(GeneratedExtensionBase<TExtension> extension, TExtension value) { + ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt; + message.VerifyExtensionContainingType(extension); + message.Extensions[extension.Descriptor] = extension.ToReflectionType(value); + return ThisBuilder; + } + + /// <summary> + /// Sets the value of one element of a repeated extension. + /// </summary> + public TBuilder SetExtension<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension, int index, TExtension value) { + ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt; + message.VerifyExtensionContainingType(extension); + message.Extensions[extension.Descriptor, index] = extension.SingularToReflectionType(value); + return ThisBuilder; + } + + /// <summary> + /// Appends a value to a repeated extension. + /// </summary> + public ExtendableBuilder<TMessage, TBuilder> AddExtension<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension, TExtension value) { + ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt; + message.VerifyExtensionContainingType(extension); + message.Extensions.AddRepeatedField(extension.Descriptor, extension.SingularToReflectionType(value)); + return this; + } + + /// <summary> + /// Clears an extension. + /// </summary> + public ExtendableBuilder<TMessage, TBuilder> ClearExtension<TExtension>(GeneratedExtensionBase<TExtension> extension) { + ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt; + message.VerifyExtensionContainingType(extension); + message.Extensions.ClearField(extension.Descriptor); + return this; + } + + /// <summary> + /// Called by subclasses to parse an unknown field or an extension. + /// </summary> + /// <returns>true unless the tag is an end-group tag</returns> + protected override bool ParseUnknownField(CodedInputStream input, UnknownFieldSet.Builder unknownFields, + ExtensionRegistry extensionRegistry, uint tag) { + return unknownFields.MergeFieldFrom(input, extensionRegistry, this, tag); + } + + // --------------------------------------------------------------- + // Reflection + + + public override object this[FieldDescriptor field, int index] { + set { + if (field.IsExtension) { + ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt; + message.VerifyContainingType(field); + message.Extensions[field, index] = value; + } else { + base[field, index] = value; + } + } + } + + + public override object this[FieldDescriptor field] { + set { + if (field.IsExtension) { + ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt; + message.VerifyContainingType(field); + message.Extensions[field] = value; + } else { + base[field] = value; + } + } + } + + public override TBuilder ClearField(FieldDescriptor field) { + if (field.IsExtension) { + ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt; + message.VerifyContainingType(field); + message.Extensions.ClearField(field); + return ThisBuilder; + } else { + return base.ClearField(field); + } + } + + public override TBuilder AddRepeatedField(FieldDescriptor field, object value) { + if (field.IsExtension) { + ExtendableMessage<TMessage, TBuilder> message = MessageBeingBuilt; + message.VerifyContainingType(field); + message.Extensions.AddRepeatedField(field, value); + return ThisBuilder; + } else { + return base.AddRepeatedField(field, value); + } + } + } +} diff --git a/src/ProtocolBuffers/ExtendableMessage.cs b/src/ProtocolBuffers/ExtendableMessage.cs new file mode 100644 index 00000000..a4a6e17e --- /dev/null +++ b/src/ProtocolBuffers/ExtendableMessage.cs @@ -0,0 +1,200 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Collections; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + public abstract class ExtendableMessage<TMessage, TBuilder> : GeneratedMessage<TMessage, TBuilder> + where TMessage : GeneratedMessage<TMessage, TBuilder> + where TBuilder : GeneratedBuilder<TMessage, TBuilder> { + + protected ExtendableMessage() {} + private readonly FieldSet extensions = FieldSet.CreateInstance(); + + /// <summary> + /// Access for the builder. + /// </summary> + internal FieldSet Extensions { + get { return extensions; } + } + + /// <summary> + /// Checks if a singular extension is present. + /// </summary> + public bool HasExtension<TExtension>(GeneratedExtensionBase<TExtension> extension) { + return extensions.HasField(extension.Descriptor); + } + + /// <summary> + /// Returns the number of elements in a repeated extension. + /// </summary> + public int GetExtensionCount<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension) { + return extensions.GetRepeatedFieldCount(extension.Descriptor); + } + + /// <summary> + /// Returns the value of an extension. + /// </summary> + public TExtension GetExtension<TExtension>(GeneratedExtensionBase<TExtension> extension) { + object value = extensions[extension.Descriptor]; + if (value == null) { + return (TExtension) extension.MessageDefaultInstance; + } else { + return (TExtension) extension.FromReflectionType(value); + } + } + + /// <summary> + /// Returns one element of a repeated extension. + /// </summary> + public TExtension GetExtension<TExtension>(GeneratedExtensionBase<IList<TExtension>> extension, int index) { + return (TExtension) extension.SingularFromReflectionType(extensions[extension.Descriptor, index]); + } + + /// <summary> + /// Called to check if all extensions are initialized. + /// </summary> + protected bool ExtensionsAreInitialized { + get { return extensions.IsInitialized; } + } + + public override bool IsInitialized { + get { + return base.IsInitialized && ExtensionsAreInitialized; + } + } + + #region Reflection + public override IDictionary<FieldDescriptor, object> AllFields { + get { + IDictionary<FieldDescriptor, object> result = GetMutableFieldMap(); + foreach(KeyValuePair<FieldDescriptor, object> entry in extensions.AllFields) { + result[entry.Key] = entry.Value; + } + return Dictionaries.AsReadOnly(result); + } + } + + public override bool HasField(FieldDescriptor field) { + if (field.IsExtension) { + VerifyContainingType(field); + return extensions.HasField(field); + } else { + return base.HasField(field); + } + } + + public override object this[FieldDescriptor field] { + get { + if (field.IsExtension) { + VerifyContainingType(field); + object value = extensions[field]; + if (value == null) { + // Lacking an ExtensionRegistry, we have no way to determine the + // extension's real type, so we return a DynamicMessage. + // TODO(jonskeet): Work out what this means + return DynamicMessage.GetDefaultInstance(field.MessageType); + } else { + return value; + } + } else { + return base[field]; + } + } + } + + public override int GetRepeatedFieldCount(FieldDescriptor field) { + if (field.IsExtension) { + VerifyContainingType(field); + return extensions.GetRepeatedFieldCount(field); + } else { + return base.GetRepeatedFieldCount(field); + } + } + + public override object this[FieldDescriptor field, int index] { + get { + if (field.IsExtension) { + VerifyContainingType(field); + return extensions[field, index]; + } else { + return base[field, index]; + } + } + } + + internal void VerifyContainingType(FieldDescriptor field) { + if (field.ContainingType != DescriptorForType) { + throw new ArgumentException("FieldDescriptor does not match message type."); + } + } + #endregion + + /// <summary> + /// Used by subclasses to serialize extensions. Extension ranges may be + /// interleaves with field numbers, but we must write them in canonical + /// (sorted by field number) order. This class helps us to write individual + /// ranges of extensions at once. + /// + /// TODO(jonskeet): See if we can improve this in terms of readability. + /// </summary> + protected class ExtensionWriter { + readonly IEnumerator<KeyValuePair<FieldDescriptor, object>> iterator; + readonly FieldSet extensions; + KeyValuePair<FieldDescriptor, object>? next = null; + + internal ExtensionWriter(ExtendableMessage<TMessage, TBuilder> message) { + extensions = message.extensions; + iterator = message.extensions.GetEnumerator(); + if (iterator.MoveNext()) { + next = iterator.Current; + } + } + + public void WriteUntil(int end, CodedOutputStream output) { + while (next != null && next.Value.Key.FieldNumber < end) { + extensions.WriteField(next.Value.Key, next.Value.Value, output); + if (iterator.MoveNext()) { + next = iterator.Current; + } else { + next = null; + } + } + } + } + + protected ExtensionWriter CreateExtensionWriter(ExtendableMessage<TMessage, TBuilder> message) { + return new ExtensionWriter(message); + } + + /// <summary> + /// Called by subclasses to compute the size of extensions. + /// </summary> + protected int ExtensionsSerializedSize { + get { return extensions.SerializedSize; } + } + + internal void VerifyExtensionContainingType<TExtension>(GeneratedExtensionBase<TExtension> extension) { + if (extension.Descriptor.ContainingType != DescriptorForType) { + // This can only happen if someone uses unchecked operations. + throw new ArgumentException("Extension is for type \"" + extension.Descriptor.ContainingType.FullName + + "\" which does not match message type \"" + DescriptorForType.FullName + "\"."); + } + } + } +} diff --git a/src/ProtocolBuffers/ExtensionInfo.cs b/src/ProtocolBuffers/ExtensionInfo.cs new file mode 100644 index 00000000..00cf0d00 --- /dev/null +++ b/src/ProtocolBuffers/ExtensionInfo.cs @@ -0,0 +1,40 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers +{ + public sealed class ExtensionInfo { + /// <summary> + /// The extension's descriptor + /// </summary> + public FieldDescriptor Descriptor { get; private set; } + + /// <summary> + /// A default instance of the extensions's type, if it has a message type, + /// or null otherwise. + /// </summary> + public IMessage DefaultInstance { get; private set; } + + internal ExtensionInfo(FieldDescriptor descriptor) : this(descriptor, null) { + } + + internal ExtensionInfo(FieldDescriptor descriptor, IMessage defaultInstance) { + Descriptor = descriptor; + DefaultInstance = defaultInstance; + } + } +}
\ No newline at end of file diff --git a/src/ProtocolBuffers/ExtensionRegistry.cs b/src/ProtocolBuffers/ExtensionRegistry.cs new file mode 100644 index 00000000..dec75733 --- /dev/null +++ b/src/ProtocolBuffers/ExtensionRegistry.cs @@ -0,0 +1,226 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; +using System; + +namespace Google.ProtocolBuffers { + /// <summary> + /// A table of known extensions, searchable by name or field number. When + /// parsing a protocol message that might have extensions, you must provide + /// an <see cref="ExtensionRegistry"/> in which you have registered any extensions + /// that you want to be able to parse. Otherwise, those extensions will just + /// be treated like unknown fields. + /// </summary> + /// <example> + /// For example, if you had the <c>.proto</c> file: + /// <code> + /// option java_class = "MyProto"; + /// + /// message Foo { + /// extensions 1000 to max; + /// } + /// + /// extend Foo { + /// optional int32 bar; + /// } + /// </code> + /// + /// Then you might write code like: + /// + /// <code> + /// ExtensionRegistry registry = ExtensionRegistry.CreateInstance(); + /// registry.Add(MyProto.Bar); + /// MyProto.Foo message = MyProto.Foo.ParseFrom(input, registry); + /// </code> + /// </example> + /// + /// <remarks> + /// <para>You might wonder why this is necessary. Two alternatives might come to + /// mind. First, you might imagine a system where generated extensions are + /// automatically registered when their containing classes are loaded. This + /// is a popular technique, but is bad design; among other things, it creates a + /// situation where behavior can change depending on what classes happen to be + /// loaded. It also introduces a security vulnerability, because an + /// unprivileged class could cause its code to be called unexpectedly from a + /// privileged class by registering itself as an extension of the right type. + /// </para> + /// <para>Another option you might consider is lazy parsing: do not parse an + /// extension until it is first requested, at which point the caller must + /// provide a type to use. This introduces a different set of problems. First, + /// it would require a mutex lock any time an extension was accessed, which + /// would be slow. Second, corrupt data would not be detected until first + /// access, at which point it would be much harder to deal with it. Third, it + /// could violate the expectation that message objects are immutable, since the + /// type provided could be any arbitrary message class. An unprivileged user + /// could take advantage of this to inject a mutable object into a message + /// belonging to privileged code and create mischief.</para> + /// </remarks> + public sealed class ExtensionRegistry { + + private static readonly ExtensionRegistry empty = new ExtensionRegistry( + new Dictionary<string, ExtensionInfo>(), + new Dictionary<DescriptorIntPair, ExtensionInfo>(), + true); + + private readonly IDictionary<string, ExtensionInfo> extensionsByName; + private readonly IDictionary<DescriptorIntPair, ExtensionInfo> extensionsByNumber; + private readonly bool readOnly; + + private ExtensionRegistry(IDictionary<String, ExtensionInfo> extensionsByName, + IDictionary<DescriptorIntPair, ExtensionInfo> extensionsByNumber, + bool readOnly) { + this.extensionsByName = extensionsByName; + this.extensionsByNumber = extensionsByNumber; + this.readOnly = readOnly; + } + + /// <summary> + /// Construct a new, empty instance. + /// </summary> + public static ExtensionRegistry CreateInstance() { + return new ExtensionRegistry(new Dictionary<string, ExtensionInfo>(), + new Dictionary<DescriptorIntPair, ExtensionInfo>(), false); + } + + /// <summary> + /// Get the unmodifiable singleton empty instance. + /// </summary> + public static ExtensionRegistry Empty { + get { return empty; } + } + + public ExtensionRegistry AsReadOnly() { + return new ExtensionRegistry(extensionsByName, extensionsByNumber, true); + } + + /// <summary> + /// Finds an extension by fully-qualified field name, in the + /// proto namespace, i.e. result.Descriptor.FullName will match + /// <paramref name="fullName"/> if a match is found. A null + /// reference is returned if the extension can't be found. + /// </summary> + public ExtensionInfo this[string fullName] { + get { + ExtensionInfo ret; + extensionsByName.TryGetValue(fullName, out ret); + return ret; + } + } + + /// <summary> + /// Finds an extension by containing type and field number. + /// A null reference is returned if the extension can't be found. + /// </summary> + public ExtensionInfo this[MessageDescriptor containingType, int fieldNumber] { + get { + ExtensionInfo ret; + extensionsByNumber.TryGetValue(new DescriptorIntPair(containingType, fieldNumber), out ret); + return ret; + } + } + + /// <summary> + /// Add an extension from a generated file to the registry. + /// </summary> + public void Add<TExtension> (GeneratedExtensionBase<TExtension> extension) { + if (extension.Descriptor.MappedType == MappedType.Message) { + Add(new ExtensionInfo(extension.Descriptor, extension.MessageDefaultInstance)); + } else { + Add(new ExtensionInfo(extension.Descriptor, null)); + } + } + + /// <summary> + /// Adds a non-message-type extension to the registry by descriptor. + /// </summary> + /// <param name="type"></param> + public void Add(FieldDescriptor type) { + if (type.MappedType == MappedType.Message) { + throw new ArgumentException("ExtensionRegistry.Add() must be provided a default instance " + + "when adding an embedded message extension."); + } + Add(new ExtensionInfo(type, null)); + } + + /// <summary> + /// Adds a message-type-extension to the registry by descriptor. + /// </summary> + /// <param name="type"></param> + /// <param name="defaultInstance"></param> + public void Add(FieldDescriptor type, IMessage defaultInstance) { + if (type.MappedType != MappedType.Message) { + throw new ArgumentException("ExtensionRegistry.Add() provided a default instance for a " + + "non-message extension."); + } + Add(new ExtensionInfo(type, defaultInstance)); + } + + private void Add(ExtensionInfo extension) { + if (readOnly) { + throw new InvalidOperationException("Cannot add entries to a read-only extension registry"); + } + if (!extension.Descriptor.IsExtension) { + throw new ArgumentException("ExtensionRegistry.add() was given a FieldDescriptor for a " + + "regular (non-extension) field."); + } + + extensionsByName[extension.Descriptor.FullName] = extension; + extensionsByNumber[new DescriptorIntPair(extension.Descriptor.ContainingType, + extension.Descriptor.FieldNumber)] = extension; + + FieldDescriptor field = extension.Descriptor; + if (field.ContainingType.Options.MessageSetWireFormat + && field.FieldType == FieldType.Message + && field.IsOptional + && field.ExtensionScope == field.MessageType) { + // This is an extension of a MessageSet type defined within the extension + // type's own scope. For backwards-compatibility, allow it to be looked + // up by type name. + extensionsByName[field.MessageType.FullName] = extension; + } + } + + /// <summary> + /// Nested type just used to represent a pair of MessageDescriptor and int, as + /// the key into the "by number" map. + /// </summary> + private struct DescriptorIntPair : IEquatable<DescriptorIntPair> { + readonly MessageDescriptor descriptor; + readonly int number; + + internal DescriptorIntPair(MessageDescriptor descriptor, int number) { + this.descriptor = descriptor; + this.number = number; + } + + public override int GetHashCode() { + return descriptor.GetHashCode() * ((1 << 16) - 1) + number; + } + + public override bool Equals(object obj) { + if (!(obj is DescriptorIntPair)) { + return false; + } + return Equals((DescriptorIntPair)obj); + } + + public bool Equals(DescriptorIntPair other) { + return descriptor == other.descriptor && number == other.number; + } + } + } +} diff --git a/src/ProtocolBuffers/FieldAccess/FieldAccessorTable.cs b/src/ProtocolBuffers/FieldAccess/FieldAccessorTable.cs new file mode 100644 index 00000000..c7f5da6d --- /dev/null +++ b/src/ProtocolBuffers/FieldAccess/FieldAccessorTable.cs @@ -0,0 +1,84 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.FieldAccess { + /// <summary> + /// Provides access to fields in generated messages via reflection. + /// This type is public to allow it to be used by generated messages, which + /// create appropriate instances in the .proto file description class. + /// TODO(jonskeet): See if we can hide it somewhere... + /// </summary> + public sealed class FieldAccessorTable<TMessage, TBuilder> + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + + readonly IFieldAccessor<TMessage, TBuilder>[] accessors; + + readonly MessageDescriptor descriptor; + + public MessageDescriptor Descriptor { + get { return descriptor; } + } + + /// <summary> + /// Constructs a FieldAccessorTable for a particular message class. + /// Only one FieldAccessorTable should be constructed per class. + /// </summary> + /// <param name="descriptor">The type's descriptor</param> + /// <param name="propertyNames">The Pascal-case names of all the field-based properties in the message.</param> + public FieldAccessorTable(MessageDescriptor descriptor, String[] propertyNames) { + this.descriptor = descriptor; + accessors = new IFieldAccessor<TMessage, TBuilder>[descriptor.Fields.Count]; + for (int i=0; i < accessors.Length; i++) { + accessors[i] = CreateAccessor(descriptor.Fields[i], propertyNames[i]); + } + } + + /// <summary> + /// Creates an accessor for a single field + /// </summary> + private static IFieldAccessor<TMessage, TBuilder> CreateAccessor(FieldDescriptor field, string name) { + if (field.IsRepeated) { + switch (field.MappedType) { + case MappedType.Message: return new RepeatedMessageAccessor<TMessage, TBuilder>(name); + case MappedType.Enum: return new RepeatedEnumAccessor<TMessage, TBuilder>(field, name); + default: return new RepeatedPrimitiveAccessor<TMessage, TBuilder>(name); + } + } else { + switch (field.MappedType) { + case MappedType.Message: return new SingleMessageAccessor<TMessage, TBuilder>(name); + case MappedType.Enum: return new SingleEnumAccessor<TMessage, TBuilder>(field, name); + default: return new SinglePrimitiveAccessor<TMessage, TBuilder>(name); + } + } + } + + internal IFieldAccessor<TMessage, TBuilder> this[FieldDescriptor field] { + get { + if (field.ContainingType != descriptor) { + throw new ArgumentException("FieldDescriptor does not match message type."); + } else if (field.IsExtension) { + // If this type had extensions, it would subclass ExtendableMessage, + // which overrides the reflection interface to handle extensions. + throw new ArgumentException("This type does not have extensions."); + } + return accessors[field.Index]; + } + } + } +} diff --git a/src/ProtocolBuffers/FieldAccess/IFieldAccessor.cs b/src/ProtocolBuffers/FieldAccess/IFieldAccessor.cs new file mode 100644 index 00000000..ec079f92 --- /dev/null +++ b/src/ProtocolBuffers/FieldAccess/IFieldAccessor.cs @@ -0,0 +1,75 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +namespace Google.ProtocolBuffers.FieldAccess { + + /// <summary> + /// Allows fields to be reflectively accessed in a smart manner. + /// The property descriptors for each field are created once and then cached. + /// In addition, this interface holds knowledge of repeated fields, builders etc. + /// </summary> + internal interface IFieldAccessor<TMessage, TBuilder> + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + + /// <summary> + /// Indicates whether the specified message contains the field. + /// </summary> + bool Has(TMessage message); + + /// <summary> + /// Gets the count of the repeated field in the specified message. + /// </summary> + int GetRepeatedCount(TMessage message); + + /// <summary> + /// Clears the field in the specified builder. + /// </summary> + /// <param name="builder"></param> + void Clear(TBuilder builder); + + /// <summary> + /// Creates a builder for the type of this field (which must be a message field). + /// </summary> + IBuilder CreateBuilder(); + + /// <summary> + /// Accessor for single fields + /// </summary> + object GetValue(TMessage message); + /// <summary> + /// Mutator for single fields + /// </summary> + void SetValue(TBuilder builder, object value); + + /// <summary> + /// Accessor for repeated fields + /// </summary> + object GetRepeatedValue(TMessage message, int index); + /// <summary> + /// Mutator for repeated fields + /// </summary> + void SetRepeated(TBuilder builder, int index, object value); + /// <summary> + /// Adds the specified value to the field in the given builder. + /// </summary> + void AddRepeated(TBuilder builder, object value); + /// <summary> + /// Returns a read-only wrapper around the value of a repeated field. + /// </summary> + object GetRepeatedWrapper(TBuilder builder); + } +} diff --git a/src/ProtocolBuffers/FieldAccess/ReflectionUtil.cs b/src/ProtocolBuffers/FieldAccess/ReflectionUtil.cs new file mode 100644 index 00000000..ddec2229 --- /dev/null +++ b/src/ProtocolBuffers/FieldAccess/ReflectionUtil.cs @@ -0,0 +1,109 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Reflection; + +namespace Google.ProtocolBuffers.FieldAccess { + + /// <summary> + /// The methods in this class are somewhat evil, and should not be tampered with lightly. + /// Basically they allow the creation of relatively weakly typed delegates from MethodInfos + /// which are more strongly typed. They do this by creating an appropriate strongly typed + /// delegate from the MethodInfo, and then calling that within an anonymous method. + /// Mind-bending stuff (at least to your humble narrator) but the resulting delegates are + /// very fast compared with calling Invoke later on. + /// </summary> + internal static class ReflectionUtil { + + /// <summary> + /// Creates a delegate which will execute the given method and then return + /// the result as an object. + /// </summary> + public static Func<T, object> CreateUpcastDelegate<T>(MethodInfo method) { + + // The tricky bit is invoking CreateCreateUpcastDelegateImpl with the right type parameters + MethodInfo openImpl = typeof(ReflectionUtil).GetMethod("CreateUpcastDelegateImpl"); + MethodInfo closedImpl = openImpl.MakeGenericMethod(typeof(T), method.ReturnType); + return (Func<T, object>) closedImpl.Invoke(null, new object[] { method }); + } + + /// <summary> + /// Method used solely for implementing CreateUpcastDelegate. Public to avoid trust issues + /// in low-trust scenarios, e.g. Silverlight. + /// TODO(jonskeet): Check any of this actually works in Silverlight... + /// </summary> + public static Func<TSource, object> CreateUpcastDelegateImpl<TSource, TResult>(MethodInfo method) { + // Convert the reflection call into an open delegate, i.e. instead of calling x.Method() + // we'll call getter(x). + Func<TSource, TResult> getter = (Func<TSource, TResult>)Delegate.CreateDelegate(typeof(Func<TSource, TResult>), method); + + // Implicit upcast to object (within the delegate) + return delegate(TSource source) { return getter(source); }; + } + + + /// <summary> + /// Creates a delegate which will execute the given method after casting the parameter + /// down from object to the required parameter type. + /// </summary> + public static Action<T, object> CreateDowncastDelegate<T>(MethodInfo method) { + MethodInfo openImpl = typeof(ReflectionUtil).GetMethod("CreateDowncastDelegateImpl"); + MethodInfo closedImpl = openImpl.MakeGenericMethod(typeof(T), method.GetParameters()[0].ParameterType); + return (Action<T, object>) closedImpl.Invoke(null, new object[] { method }); + } + + public static Action<TSource, object> CreateDowncastDelegateImpl<TSource, TParam>(MethodInfo method) { + // Convert the reflection call into an open delegate, i.e. instead of calling x.Method(y) we'll + // call Method(x, y) + Action<TSource, TParam> call = (Action<TSource, TParam>) Delegate.CreateDelegate(typeof(Action<TSource, TParam>), method); + + return delegate(TSource source, object parameter) { call(source, (TParam)parameter); }; + } + + /// <summary> + /// Creates a delegate which will execute the given method after casting the parameter + /// down from object to the required parameter type. + /// </summary> + public static Action<T, object> CreateDowncastDelegateIgnoringReturn<T>(MethodInfo method) { + MethodInfo openImpl = typeof(ReflectionUtil).GetMethod("CreateDowncastDelegateIgnoringReturnImpl"); + MethodInfo closedImpl = openImpl.MakeGenericMethod(typeof(T), method.GetParameters()[0].ParameterType, method.ReturnType); + return (Action<T, object>)closedImpl.Invoke(null, new object[] { method }); + } + + public static Action<TSource, object> CreateDowncastDelegateIgnoringReturnImpl<TSource, TParam, TReturn>(MethodInfo method) { + // Convert the reflection call into an open delegate, i.e. instead of calling x.Method(y) we'll + // call Method(x, y) + Func<TSource, TParam, TReturn> call = (Func<TSource, TParam, TReturn>) + Delegate.CreateDelegate(typeof(Func<TSource, TParam, TReturn>), method); + + return delegate(TSource source, object parameter) { call(source, (TParam)parameter); }; + } + + /// <summary> + /// Creates a delegate which will execute the given static method and cast the result up to IBuilder. + /// </summary> + public static Func<IBuilder> CreateStaticUpcastDelegate(MethodInfo method) { + MethodInfo openImpl = typeof(ReflectionUtil).GetMethod("CreateStaticUpcastDelegateImpl"); + MethodInfo closedImpl = openImpl.MakeGenericMethod(method.ReturnType); + return (Func<IBuilder>)closedImpl.Invoke(null, new object[] { method }); + } + + public static Func<IBuilder> CreateStaticUpcastDelegateImpl<T>(MethodInfo method) { + Func<T> call = (Func<T>)Delegate.CreateDelegate(typeof(Func<T>), method); + return delegate { return (IBuilder)call(); }; + } + } +} diff --git a/src/ProtocolBuffers/FieldAccess/RepeatedEnumAccessor.cs b/src/ProtocolBuffers/FieldAccess/RepeatedEnumAccessor.cs new file mode 100644 index 00000000..f00f7ee2 --- /dev/null +++ b/src/ProtocolBuffers/FieldAccess/RepeatedEnumAccessor.cs @@ -0,0 +1,60 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; +using Google.ProtocolBuffers.Collections; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.FieldAccess { + + /// <summary> + /// Accessor for a repeated enum field. + /// </summary> + internal sealed class RepeatedEnumAccessor<TMessage, TBuilder> : RepeatedPrimitiveAccessor<TMessage, TBuilder> + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + + private readonly EnumDescriptor enumDescriptor; + + internal RepeatedEnumAccessor(FieldDescriptor field, string name) : base(name) { + enumDescriptor = field.EnumType; + } + + public override object GetValue(TMessage message) { + List<EnumValueDescriptor> ret = new List<EnumValueDescriptor>(); + foreach (int rawValue in (IEnumerable) base.GetValue(message)) { + ret.Add(enumDescriptor.FindValueByNumber(rawValue)); + } + return Lists.AsReadOnly(ret); + } + + public override object GetRepeatedValue(TMessage message, int index) { + // Note: This relies on the fact that the CLR allows unboxing from an enum to + // its underlying value + int rawValue = (int) base.GetRepeatedValue(message, index); + return enumDescriptor.FindValueByNumber(rawValue); + } + + public override void AddRepeated(TBuilder builder, object value) { + base.AddRepeated(builder, ((EnumValueDescriptor) value).Number); + } + + public override void SetRepeated(TBuilder builder, int index, object value) { + base.SetRepeated(builder, index, ((EnumValueDescriptor) value).Number); + } + } +} diff --git a/src/ProtocolBuffers/FieldAccess/RepeatedMessageAccessor.cs b/src/ProtocolBuffers/FieldAccess/RepeatedMessageAccessor.cs new file mode 100644 index 00000000..35d7b1a8 --- /dev/null +++ b/src/ProtocolBuffers/FieldAccess/RepeatedMessageAccessor.cs @@ -0,0 +1,74 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Reflection; + +namespace Google.ProtocolBuffers.FieldAccess { + + /// <summary> + /// Accessor for a repeated message field. + /// + /// TODO(jonskeet): Try to extract the commonality between this and SingleMessageAccessor. + /// We almost want multiple inheritance... + /// </summary> + internal sealed class RepeatedMessageAccessor<TMessage, TBuilder> : RepeatedPrimitiveAccessor<TMessage, TBuilder> + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + + /// <summary> + /// The static method to create a builder for the property type. For example, + /// in a message type "Foo", a field called "bar" might be of type "Baz". This + /// method is Baz.CreateBuilder. + /// </summary> + private readonly Func<IBuilder> createBuilderDelegate; + + internal RepeatedMessageAccessor(string name) : base(name) { + MethodInfo createBuilderMethod = ClrType.GetMethod("CreateBuilder", Type.EmptyTypes); + if (createBuilderMethod == null) { + throw new ArgumentException("No public static CreateBuilder method declared in " + ClrType.Name); + } + createBuilderDelegate = ReflectionUtil.CreateStaticUpcastDelegate(createBuilderMethod); + } + + /// <summary> + /// Creates a message of the appropriate CLR type from the given value, + /// which may already be of the right type or may be a dynamic message. + /// </summary> + private object CoerceType(object value) { + + // If it's already of the right type, we're done + if (ClrType.IsInstanceOfType(value)) { + return value; + } + + // No... so let's create a builder of the right type, and merge the value in. + IMessage message = (IMessage) value; + return CreateBuilder().WeakMergeFrom(message).WeakBuild(); + } + + public override void SetRepeated(TBuilder builder, int index, object value) { + base.SetRepeated(builder, index, CoerceType(value)); + } + + public override IBuilder CreateBuilder() { + return createBuilderDelegate(); + } + + public override void AddRepeated(TBuilder builder, object value) { + base.AddRepeated(builder, CoerceType(value)); + } + } +} diff --git a/src/ProtocolBuffers/FieldAccess/RepeatedPrimitiveAccessor.cs b/src/ProtocolBuffers/FieldAccess/RepeatedPrimitiveAccessor.cs new file mode 100644 index 00000000..35a2a204 --- /dev/null +++ b/src/ProtocolBuffers/FieldAccess/RepeatedPrimitiveAccessor.cs @@ -0,0 +1,124 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Reflection; + +namespace Google.ProtocolBuffers.FieldAccess { + /// <summary> + /// Accesor for a repeated field of type int, ByteString etc. + /// </summary> + internal class RepeatedPrimitiveAccessor<TMessage, TBuilder> : IFieldAccessor<TMessage, TBuilder> + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + + private readonly Type clrType; + private readonly Func<TMessage, object> getValueDelegate; + private readonly Func<TBuilder, IBuilder> clearDelegate; + private readonly Action<TBuilder, object> addValueDelegate; + private readonly Func<TBuilder, object> getRepeatedWrapperDelegate; + private readonly Func<TMessage, int> countDelegate; + private readonly MethodInfo getElementMethod; + private readonly MethodInfo setElementMethod; + + + /// <summary> + /// The CLR type of the field (int, the enum type, ByteString, the message etc). + /// This is taken from the return type of the method used to retrieve a single + /// value. + /// </summary> + protected Type ClrType { + get { return clrType; } + } + + internal RepeatedPrimitiveAccessor(string name) { + PropertyInfo messageProperty = typeof(TMessage).GetProperty(name + "List"); + PropertyInfo builderProperty = typeof(TBuilder).GetProperty(name + "List"); + PropertyInfo countProperty = typeof(TMessage).GetProperty(name + "Count"); + MethodInfo clearMethod = typeof(TBuilder).GetMethod("Clear" + name, Type.EmptyTypes); + getElementMethod = typeof(TMessage).GetMethod("Get" + name, new Type[] { typeof(int) }); + clrType = getElementMethod.ReturnType; + MethodInfo addMethod = typeof(TBuilder).GetMethod("Add" + name, new Type[] { ClrType }); + setElementMethod = typeof(TBuilder).GetMethod("Set" + name, new Type[] { typeof(int), ClrType }); + if (messageProperty == null + || builderProperty == null + || countProperty == null + || clearMethod == null + || addMethod == null + || getElementMethod == null + || setElementMethod == null) { + throw new ArgumentException("Not all required properties/methods available"); + } + clearDelegate = (Func<TBuilder, IBuilder>)Delegate.CreateDelegate(typeof(Func<TBuilder, IBuilder>), clearMethod); + countDelegate = (Func<TMessage, int>)Delegate.CreateDelegate + (typeof(Func<TMessage, int>), countProperty.GetGetMethod()); + getValueDelegate = ReflectionUtil.CreateUpcastDelegate<TMessage>(messageProperty.GetGetMethod()); + addValueDelegate = ReflectionUtil.CreateDowncastDelegateIgnoringReturn<TBuilder>(addMethod); + getRepeatedWrapperDelegate = ReflectionUtil.CreateUpcastDelegate<TBuilder>(builderProperty.GetGetMethod()); + } + + public bool Has(TMessage message) { + throw new InvalidOperationException(); + } + + public virtual IBuilder CreateBuilder() { + throw new InvalidOperationException(); + } + + public virtual object GetValue(TMessage message) { + return getValueDelegate(message); + } + + public void SetValue(TBuilder builder, object value) { + // Add all the elements individually. This serves two purposes: + // 1) Verifies that each element has the correct type. + // 2) Insures that the caller cannot modify the list later on and + // have the modifications be reflected in the message. + Clear(builder); + foreach (object element in (IEnumerable) value) { + AddRepeated(builder, element); + } + } + + public void Clear(TBuilder builder) { + clearDelegate(builder); + } + + public int GetRepeatedCount(TMessage message) { + return countDelegate(message); + } + + public virtual object GetRepeatedValue(TMessage message, int index) { + return getElementMethod.Invoke(message, new object[] {index } ); + } + + public virtual void SetRepeated(TBuilder builder, int index, object value) { + setElementMethod.Invoke(builder, new object[] {index, value} ); + } + + public virtual void AddRepeated(TBuilder builder, object value) { + addValueDelegate(builder, value); + } + + /// <summary> + /// The builder class's accessor already builds a read-only wrapper for + /// us, which is exactly what we want. + /// </summary> + public object GetRepeatedWrapper(TBuilder builder) { + return getRepeatedWrapperDelegate(builder); + } + } +}
\ No newline at end of file diff --git a/src/ProtocolBuffers/FieldAccess/SingleEnumAccessor.cs b/src/ProtocolBuffers/FieldAccess/SingleEnumAccessor.cs new file mode 100644 index 00000000..eb28160a --- /dev/null +++ b/src/ProtocolBuffers/FieldAccess/SingleEnumAccessor.cs @@ -0,0 +1,54 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers.FieldAccess { + /// <summary> + /// Accessor for fields representing a non-repeated enum value. + /// </summary> + internal sealed class SingleEnumAccessor<TMessage, TBuilder> : SinglePrimitiveAccessor<TMessage, TBuilder> + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + + private readonly EnumDescriptor enumDescriptor; + + internal SingleEnumAccessor(FieldDescriptor field, string name) : base(name) { + enumDescriptor = field.EnumType; + } + + /// <summary> + /// Returns an EnumValueDescriptor representing the value in the builder. + /// Note that if an enum has multiple values for the same number, the descriptor + /// for the first value with that number will be returned. + /// </summary> + public override object GetValue(TMessage message) { + // Note: This relies on the fact that the CLR allows unboxing from an enum to + // its underlying value + int rawValue = (int) base.GetValue(message); + return enumDescriptor.FindValueByNumber(rawValue); + } + + /// <summary> + /// Sets the value as an enum (via an int) in the builder, + /// from an EnumValueDescriptor parameter. + /// </summary> + public override void SetValue(TBuilder builder, object value) { + EnumValueDescriptor valueDescriptor = (EnumValueDescriptor) value; + base.SetValue(builder, valueDescriptor.Number); + } + } +}
\ No newline at end of file diff --git a/src/ProtocolBuffers/FieldAccess/SingleMessageAccessor.cs b/src/ProtocolBuffers/FieldAccess/SingleMessageAccessor.cs new file mode 100644 index 00000000..5aa9f777 --- /dev/null +++ b/src/ProtocolBuffers/FieldAccess/SingleMessageAccessor.cs @@ -0,0 +1,66 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Reflection; + +namespace Google.ProtocolBuffers.FieldAccess { + /// <summary> + /// Accessor for fields representing a non-repeated message value. + /// </summary> + internal sealed class SingleMessageAccessor<TMessage, TBuilder> : SinglePrimitiveAccessor<TMessage, TBuilder> + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + + /// <summary> + /// The static method to create a builder for the property type. For example, + /// in a message type "Foo", a field called "bar" might be of type "Baz". This + /// method is Baz.CreateBuilder. + /// </summary> + private readonly Func<IBuilder> createBuilderDelegate; + + internal SingleMessageAccessor(string name) : base(name) { + MethodInfo createBuilderMethod = ClrType.GetMethod("CreateBuilder", Type.EmptyTypes); + if (createBuilderMethod == null) { + throw new ArgumentException("No public static CreateBuilder method declared in " + ClrType.Name); + } + createBuilderDelegate = ReflectionUtil.CreateStaticUpcastDelegate(createBuilderMethod); + } + + /// <summary> + /// Creates a message of the appropriate CLR type from the given value, + /// which may already be of the right type or may be a dynamic message. + /// </summary> + private object CoerceType(object value) { + + // If it's already of the right type, we're done + if (ClrType.IsInstanceOfType(value)) { + return value; + } + + // No... so let's create a builder of the right type, and merge the value in. + IMessage message = (IMessage) value; + return CreateBuilder().WeakMergeFrom(message).WeakBuild(); + } + + public override void SetValue(TBuilder builder, object value) { + base.SetValue(builder, CoerceType(value)); + } + + public override IBuilder CreateBuilder() { + return createBuilderDelegate(); + } + } +}
\ No newline at end of file diff --git a/src/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs b/src/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs new file mode 100644 index 00000000..c10936d4 --- /dev/null +++ b/src/ProtocolBuffers/FieldAccess/SinglePrimitiveAccessor.cs @@ -0,0 +1,104 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Reflection; + +namespace Google.ProtocolBuffers.FieldAccess { + /// <summary> + /// Access for a non-repeated field of a "primitive" type (i.e. not another message or an enum). + /// </summary> + internal class SinglePrimitiveAccessor<TMessage, TBuilder> : IFieldAccessor<TMessage, TBuilder> + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + + private readonly Type clrType; + private readonly Func<TMessage, object> getValueDelegate; + private readonly Action<TBuilder, object> setValueDelegate; + private readonly Func<TMessage, bool> hasDelegate; + private readonly Func<TBuilder, IBuilder> clearDelegate; + + /// <summary> + /// The CLR type of the field (int, the enum type, ByteString, the message etc). + /// As declared by the property. + /// </summary> + protected Type ClrType { + get { return clrType; } + } + + internal SinglePrimitiveAccessor(string name) { + + string propertyName = name == typeof(TMessage).Name ? name + "_" : name; + PropertyInfo messageProperty = typeof(TMessage).GetProperty(propertyName); + PropertyInfo builderProperty = typeof(TBuilder).GetProperty(name); // FIXME! + if (builderProperty == null) builderProperty = typeof(TBuilder).GetProperty(propertyName); // FIXME! + PropertyInfo hasProperty = typeof(TMessage).GetProperty("Has" + name); + MethodInfo clearMethod = typeof(TBuilder).GetMethod("Clear" + name, Type.EmptyTypes); + if (messageProperty == null || builderProperty == null || hasProperty == null || clearMethod == null) { + throw new ArgumentException("Not all required properties/methods available"); + } + clrType = messageProperty.PropertyType; + hasDelegate = (Func<TMessage, bool>)Delegate.CreateDelegate(typeof(Func<TMessage, bool>), hasProperty.GetGetMethod()); + clearDelegate = (Func<TBuilder, IBuilder>)Delegate.CreateDelegate(typeof(Func<TBuilder, IBuilder>), clearMethod); + getValueDelegate = ReflectionUtil.CreateUpcastDelegate<TMessage>(messageProperty.GetGetMethod()); + setValueDelegate = ReflectionUtil.CreateDowncastDelegate<TBuilder>(builderProperty.GetSetMethod()); + } + + public bool Has(TMessage message) { + return hasDelegate(message); + } + + public void Clear(TBuilder builder) { + clearDelegate(builder); + } + + /// <summary> + /// Only valid for message types - this implementation throws InvalidOperationException. + /// </summary> + public virtual IBuilder CreateBuilder() { + throw new InvalidOperationException(); + } + + public virtual object GetValue(TMessage message) { + return getValueDelegate(message); + } + + public virtual void SetValue(TBuilder builder, object value) { + setValueDelegate(builder, value); + } + + #region Methods only related to repeated values + public int GetRepeatedCount(TMessage message) { + throw new InvalidOperationException(); + } + + public object GetRepeatedValue(TMessage message, int index) { + throw new InvalidOperationException(); + } + + public void SetRepeated(TBuilder builder, int index, object value) { + throw new InvalidOperationException(); + } + + public void AddRepeated(TBuilder builder, object value) { + throw new InvalidOperationException(); + } + + public object GetRepeatedWrapper(TBuilder builder) { + throw new InvalidOperationException(); + } + #endregion + } +}
\ No newline at end of file diff --git a/src/ProtocolBuffers/FieldSet.cs b/src/ProtocolBuffers/FieldSet.cs new file mode 100644 index 00000000..c130d858 --- /dev/null +++ b/src/ProtocolBuffers/FieldSet.cs @@ -0,0 +1,434 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; +using Google.ProtocolBuffers.Collections; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + /// <summary> + /// A class which represents an arbitrary set of fields of some message type. + /// This is used to implement DynamicMessage, and also to represent extensions + /// in GeneratedMessage. This class is internal, since outside users should probably + /// be using DynamicMessage. + /// + /// As in the Java implementation, this class goes against the rest of the framework + /// in terms of mutability. Instead of having a mutable Builder class and an immutable + /// FieldSet class, FieldSet just has a MakeImmutable() method. This is safe so long as + /// all callers are careful not to let a mutable FieldSet escape into the open. This would + /// be impossible to guarantee if this were a public class, of course. + /// + /// All repeated fields are stored as IList[object] even + /// TODO(jonskeet): Finish this comment! + /// </summary> + internal sealed class FieldSet { + + private static readonly FieldSet defaultInstance = new FieldSet(new Dictionary<FieldDescriptor, object>()).MakeImmutable(); + + private IDictionary<FieldDescriptor, object> fields; + + private FieldSet(IDictionary<FieldDescriptor, object> fields) { + this.fields = fields; + } + + public static FieldSet CreateInstance() { + // Use SortedList to keep fields in the canonical order + return new FieldSet(new SortedList<FieldDescriptor, object>()); + } + + /// <summary> + /// Makes this FieldSet immutable, and returns it for convenience. Any + /// mutable repeated fields are made immutable, as well as the map itself. + /// </summary> + internal FieldSet MakeImmutable() { + // First check if we have any repeated values + bool hasRepeats = false; + foreach (object value in fields.Values) { + IList<object> list = value as IList<object>; + if (list != null && !list.IsReadOnly) { + hasRepeats = true; + break; + } + } + + if (hasRepeats) { + var tmp = new SortedList<FieldDescriptor, object>(); + foreach (KeyValuePair<FieldDescriptor, object> entry in fields) { + IList<object> list = entry.Value as IList<object>; + tmp[entry.Key] = list == null ? entry.Value : Lists.AsReadOnly(list); + } + fields = tmp; + } + + fields = Dictionaries.AsReadOnly(fields); + + return this; + } + + /// <summary> + /// Returns the default, immutable instance with no fields defined. + /// </summary> + internal static FieldSet DefaultInstance { + get { return defaultInstance; } + } + + /// <summary> + /// Returns an immutable mapping of fields. Note that although the mapping itself + /// is immutable, the entries may not be (i.e. any repeated values are represented by + /// mutable lists). The behaviour is not specified if the contents are mutated. + /// </summary> + internal IDictionary<FieldDescriptor, object> AllFields { + get { return Dictionaries.AsReadOnly(fields); } + } + + /// <summary> + /// See <see cref="IMessage.HasField"/>. + /// </summary> + public bool HasField(FieldDescriptor field) { + if (field.IsRepeated) { + throw new ArgumentException("HasField() can only be called on non-repeated fields."); + } + + return fields.ContainsKey(field); + } + + /// <summary> + /// Clears all fields. + /// </summary> + internal void Clear() { + fields.Clear(); + } + + /// <summary> + /// See <see cref="IMessage.Item(FieldDescriptor)"/> + /// </summary> + /// <remarks> + /// If the field is not set, the behaviour when fetching this property varies by field type: + /// <list> + /// <item>For singular message values, null is returned.</item> + /// <item>For singular non-message values, the default value of the field is returned.</item> + /// <item>For repeated values, an empty immutable list is returned. This will be compatible + /// with IList[object], regardless of the type of the repeated item.</item> + /// </list> + /// This method returns null if the field is a singular message type + /// and is not set; in this case it is up to the caller to fetch the + /// message's default instance. For repeated fields of message types, + /// an empty collection is returned. For repeated fields of non-message + /// types, null is returned. + /// <para /> + /// When setting this property, any list values are copied, and each element is checked + /// to ensure it is of an appropriate type. + /// </remarks> + /// + internal object this[FieldDescriptor field] { + get { + object result; + if (fields.TryGetValue(field, out result)) { + return result; + } + if (field.MappedType == MappedType.Message) { + if (field.IsRepeated) { + return new List<object>(); + } else { + return null; + } + } + return field.DefaultValue; + } + set { + if (field.IsRepeated) { + List<object> list = value as List<object>; + if (list == null) { + throw new ArgumentException("Wrong object type used with protocol message reflection."); + } + + // Wrap the contents in a new list so that the caller cannot change + // the list's contents after setting it. + List<object> newList = new List<object>(list); + foreach (object element in newList) { + VerifyType(field, element); + } + value = newList; + } + else { + VerifyType(field, value); + } + fields[field] = value; + } + } + + /// <summary> + /// See <see cref="IMessage.Item(FieldDescriptor,int)" /> + /// </summary> + internal object this[FieldDescriptor field, int index] { + get { + if (!field.IsRepeated) { + throw new ArgumentException("Indexer specifying field and index can only be called on repeated fields."); + } + + return ((IList<object>) this[field])[index]; + } + set { + if (!field.IsRepeated) { + throw new ArgumentException("Indexer specifying field and index can only be called on repeated fields."); + } + VerifyType(field, value); + object list; + if (!fields.TryGetValue(field, out list)) { + throw new ArgumentOutOfRangeException(); + } + ((IList<object>) list)[index] = value; + } + } + + /// <summary> + /// See <see cref="IBuilder{TMessage, TBuilder}.AddRepeatedField" /> + /// </summary> + internal void AddRepeatedField(FieldDescriptor field, object value) { + if (!field.IsRepeated) { + throw new ArgumentException("AddRepeatedField can only be called on repeated fields."); + } + VerifyType(field, value); + object list; + if (!fields.TryGetValue(field, out list)) { + list = new List<object>(); + fields[field] = list; + } + ((IList<object>) list).Add(value); + } + + /// <summary> + /// Returns an enumerator for the field map. Used to write the fields out. + /// </summary> + internal IEnumerator<KeyValuePair<FieldDescriptor, object>> GetEnumerator() { + return fields.GetEnumerator(); + } + + /// <summary> + /// See <see cref="IMessage.IsInitialized" /> + /// </summary> + /// <remarks> + /// Since FieldSet itself does not have any way of knowing about + /// required fields that aren't actually present in the set, it is up + /// to the caller to check for genuinely required fields. This property + /// merely checks that any messages present are themselves initialized. + /// </remarks> + internal bool IsInitialized { + get { + foreach (KeyValuePair<FieldDescriptor, object> entry in fields) { + FieldDescriptor field = entry.Key; + if (field.MappedType == MappedType.Message) { + if (field.IsRepeated) { + foreach(IMessage message in (IEnumerable) entry.Value) { + if (!message.IsInitialized) { + return false; + } + } + } else { + if (!((IMessage) entry.Value).IsInitialized) { + return false; + } + } + } + } + return true; + } + } + + /// <summary> + /// Verifies whether all the required fields in the specified message + /// descriptor are present in this field set, as well as whether + /// all the embedded messages are themselves initialized. + /// </summary> + internal bool IsInitializedWithRespectTo(MessageDescriptor type) { + foreach (FieldDescriptor field in type.Fields) { + if (field.IsRequired && !HasField(field)) { + return false; + } + } + return IsInitialized; + } + + /// <summary> + /// See <see cref="IBuilder{TMessage, TBuilder}.ClearField" /> + /// </summary> + public void ClearField(FieldDescriptor field) { + fields.Remove(field); + } + + /// <summary> + /// See <see cref="IMessage.GetRepeatedFieldCount" /> + /// </summary> + public int GetRepeatedFieldCount(FieldDescriptor field) { + if (!field.IsRepeated) { + throw new ArgumentException("GetRepeatedFieldCount() can only be called on repeated fields."); + } + + return ((IList<object>) this[field]).Count; + } + + /// <summary> + /// Implementation of both <c>MergeFrom</c> methods. + /// </summary> + /// <param name="otherFields"></param> + private void MergeFields(IEnumerable<KeyValuePair<FieldDescriptor, object>> otherFields) { + // Note: We don't attempt to verify that other's fields have valid + // types. Doing so would be a losing battle. We'd have to verify + // all sub-messages as well, and we'd have to make copies of all of + // them to insure that they don't change after verification (since + // the IMessage interface itself cannot enforce immutability of + // implementations). + // TODO(jonskeet): Provide a function somewhere called MakeDeepCopy() + // which allows people to make secure deep copies of messages. + + foreach (KeyValuePair<FieldDescriptor, object> entry in otherFields) { + FieldDescriptor field = entry.Key; + object existingValue; + fields.TryGetValue(field, out existingValue); + if (field.IsRepeated) { + if (existingValue == null) { + existingValue = new List<object>(); + fields[field] = existingValue; + } + IList<object> list = (IList<object>) existingValue; + foreach (object otherValue in (IEnumerable) entry.Value) { + list.Add(otherValue); + } + } else if (field.MappedType == MappedType.Message && existingValue != null) { + IMessage existingMessage = (IMessage)existingValue; + IMessage merged = existingMessage.WeakCreateBuilderForType() + .WeakMergeFrom(existingMessage) + .WeakMergeFrom((IMessage) entry.Value) + .WeakBuild(); + this[field] = merged; + } else { + this[field] = entry.Value; + } + } + } + + /// <summary> + /// See <see cref="IBuilder{TMessage, TBuilder}.MergeFrom(IMessage)" /> + /// </summary> + public void MergeFrom(IMessage other) { + MergeFields(other.AllFields); + } + + /// <summary> + /// Like <see cref="MergeFrom(IMessage)"/>, but merges from another <c>FieldSet</c>. + /// </summary> + public void MergeFrom(FieldSet other) { + MergeFields(other.fields); + } + + /// <summary> + /// See <see cref="IMessage.WriteTo(CodedOutputStream)" />. + /// </summary> + public void WriteTo(CodedOutputStream output) { + foreach (KeyValuePair<FieldDescriptor, object> entry in fields) { + WriteField(entry.Key, entry.Value, output); + } + } + + /// <summary> + /// Writes a single field to a CodedOutputStream. + /// </summary> + public void WriteField(FieldDescriptor field, Object value, CodedOutputStream output) { + if (field.IsExtension && field.ContainingType.Options.MessageSetWireFormat) { + output.WriteMessageSetExtension(field.FieldNumber, (IMessage) value); + } else { + if (field.IsRepeated) { + foreach (object element in (IEnumerable) value) { + output.WriteField(field.FieldType, field.FieldNumber, element); + } + } else { + output.WriteField(field.FieldType, field.FieldNumber, value); + } + } + } + + /// <summary> + /// See <see cref="IMessage.SerializedSize" />. It's up to the caller to + /// cache the resulting size if desired. + /// </summary> + public int SerializedSize { + get { + int size = 0; + foreach (KeyValuePair<FieldDescriptor, object> entry in fields) { + FieldDescriptor field = entry.Key; + object value = entry.Value; + + if (field.IsExtension && field.ContainingType.Options.MessageSetWireFormat) { + size += CodedOutputStream.ComputeMessageSetExtensionSize(field.FieldNumber, (IMessage) value); + } else { + if (field.IsRepeated) { + foreach (object element in (IEnumerable) value) { + size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, element); + } + } else { + size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, value); + } + } + } + return size; + } + } + + /// <summary> + /// Verifies that the given object is of the correct type to be a valid + /// value for the given field. + /// </summary> + /// <remarks> + /// For repeated fields, this checks if the object is of the right + /// element type, not whether it's a list. + /// </remarks> + /// <exception cref="ArgumentException">The value is not of the right type.</exception> + private static void VerifyType(FieldDescriptor field, object value) { + bool isValid = false; + switch (field.MappedType) { + case MappedType.Int32: isValid = value is int; break; + case MappedType.Int64: isValid = value is long; break; + case MappedType.UInt32: isValid = value is uint; break; + case MappedType.UInt64: isValid = value is ulong; break; + case MappedType.Single: isValid = value is float; break; + case MappedType.Double: isValid = value is double; break; + case MappedType.Boolean: isValid = value is bool; break; + case MappedType.String: isValid = value is string; break; + case MappedType.ByteString: isValid = value is ByteString; break; + case MappedType.Enum: + EnumValueDescriptor enumValue = value as EnumValueDescriptor; + isValid = enumValue != null && enumValue.EnumDescriptor == field.EnumType; + break; + case MappedType.Message: + IMessage messageValue = value as IMessage; + isValid = messageValue != null && messageValue.DescriptorForType == field.MessageType; + break; + } + + if (!isValid) { + // When chaining calls to SetField(), it can be hard to tell from + // the stack trace which exact call failed, since the whole chain is + // considered one line of code. So, let's make sure to include the + // field name and other useful info in the exception. + throw new ArgumentException("Wrong object type used with protocol message reflection. " + + "Message type \"" + field.ContainingType.FullName + + "\", field \"" + (field.IsExtension ? field.FullName : field.Name) + + "\", value was type \"" + value.GetType().Name + "\"."); + } + } + } +} diff --git a/src/ProtocolBuffers/GeneratedBuilder.cs b/src/ProtocolBuffers/GeneratedBuilder.cs new file mode 100644 index 00000000..4f577a79 --- /dev/null +++ b/src/ProtocolBuffers/GeneratedBuilder.cs @@ -0,0 +1,177 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.FieldAccess; + +namespace Google.ProtocolBuffers { + /// <summary> + /// All generated protocol message builder classes extend this class. It implements + /// most of the IBuilder interface using reflection. Users can ignore this class + /// as an implementation detail. + /// </summary> + public abstract class GeneratedBuilder<TMessage, TBuilder> : AbstractBuilder<TMessage, TBuilder> + where TMessage : GeneratedMessage <TMessage, TBuilder> + where TBuilder : GeneratedBuilder<TMessage, TBuilder> { + + /// <summary> + /// Returns the message being built at the moment. + /// </summary> + protected abstract TMessage MessageBeingBuilt { get; } + + protected internal FieldAccessorTable<TMessage, TBuilder> InternalFieldAccessors { + get { return MessageBeingBuilt.FieldAccessorsFromBuilder; } + } + + public override bool IsInitialized { + get { return MessageBeingBuilt.IsInitialized; } + } + + public override IDictionary<FieldDescriptor, object> AllFields { + get { return MessageBeingBuilt.AllFields; } + } + + public override object this[FieldDescriptor field] { + get { + // For repeated fields, the underlying list object is still modifiable at this point. + // Make sure not to expose the modifiable list to the caller. + return field.IsRepeated + ? InternalFieldAccessors[field].GetRepeatedWrapper(ThisBuilder) + : MessageBeingBuilt[field]; + } + set { + InternalFieldAccessors[field].SetValue(ThisBuilder, value); + } + } + + /// <summary> + /// Adds all of the specified values to the given collection. + /// </summary> + protected void AddRange<T>(IEnumerable<T> source, IList<T> destination) { + List<T> list = destination as List<T>; + if (list != null) { + list.AddRange(source); + } else { + foreach (T element in source) { + destination.Add(element); + } + } + } + + /// <summary> + /// Called by derived classes to parse an unknown field. + /// </summary> + /// <returns>true unless the tag is an end-group tag</returns> + protected virtual bool ParseUnknownField(CodedInputStream input, UnknownFieldSet.Builder unknownFields, + ExtensionRegistry extensionRegistry, uint tag) { + return unknownFields.MergeFieldFrom(tag, input); + } + + public override MessageDescriptor DescriptorForType { + get { return MessageBeingBuilt.DescriptorForType; } + } + + public override int GetRepeatedFieldCount(FieldDescriptor field) { + return MessageBeingBuilt.GetRepeatedFieldCount(field); + } + + public override object this[FieldDescriptor field, int index] { + get { return MessageBeingBuilt[field, index]; } + set { InternalFieldAccessors[field].SetRepeated(ThisBuilder, index, value); } + } + + public override bool HasField(FieldDescriptor field) { + return MessageBeingBuilt.HasField(field); + } + + public override IBuilder CreateBuilderForField(FieldDescriptor field) { + return InternalFieldAccessors[field].CreateBuilder(); + } + + public override TBuilder ClearField(FieldDescriptor field) { + InternalFieldAccessors[field].Clear(ThisBuilder); + return ThisBuilder; + } + + public override TBuilder MergeFrom(TMessage other) { + if (other.DescriptorForType != InternalFieldAccessors.Descriptor) { + throw new ArgumentException("Message type mismatch"); + } + + foreach (KeyValuePair<FieldDescriptor, object> entry in AllFields) { + FieldDescriptor field = entry.Key; + if (field.IsRepeated) { + // Concatenate repeated fields + foreach (object element in (IEnumerable)entry.Value) { + AddRepeatedField(field, element); + } + } else if (field.MappedType == MappedType.Message && HasField(field)) { + // Merge singular embedded messages + IMessage oldValue = (IMessage)this[field]; + this[field] = oldValue.WeakCreateBuilderForType() + .WeakMergeFrom(oldValue) + .WeakMergeFrom((IMessage)entry.Value) + .WeakBuildPartial(); + } else { + // Just overwrite + this[field] = entry.Value; + } + } + return ThisBuilder; + } + + public override TBuilder MergeUnknownFields(UnknownFieldSet unknownFields) { + TMessage result = MessageBeingBuilt; + result.SetUnknownFields(UnknownFieldSet.CreateBuilder(result.UnknownFields) + .MergeFrom(unknownFields) + .Build()); + return ThisBuilder; + } + + public override TBuilder AddRepeatedField(FieldDescriptor field, object value) { + InternalFieldAccessors[field].AddRepeated(ThisBuilder, value); + return ThisBuilder; + } + + /// <summary> + /// Like Build(), but will wrap UninitializedMessageException in + /// InvalidProtocolBufferException. + /// </summary> + public TMessage BuildParsed() { + if (!IsInitialized) { + throw new UninitializedMessageException(MessageBeingBuilt).AsInvalidProtocolBufferException(); + } + return BuildPartial(); + } + + /// <summary> + /// Implementation of <see cref="IBuilder{TMessage, TBuilder}.Build" />. + /// </summary> + public override TMessage Build() { + if (!IsInitialized) { + throw new UninitializedMessageException(MessageBeingBuilt); + } + return BuildPartial(); + } + + public override UnknownFieldSet UnknownFields { + get { return MessageBeingBuilt.UnknownFields; } + set { MessageBeingBuilt.SetUnknownFields(value); } + } + } +} diff --git a/src/ProtocolBuffers/GeneratedExtensionBase.cs b/src/ProtocolBuffers/GeneratedExtensionBase.cs new file mode 100644 index 00000000..5d8e2845 --- /dev/null +++ b/src/ProtocolBuffers/GeneratedExtensionBase.cs @@ -0,0 +1,136 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; +using System.Reflection; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Base type for all generated extensions. + /// </summary> + /// <remarks> + /// The protocol compiler generates a static singleton instance of this + /// class for each extension. For exmaple, imagine a .proto file with: + /// <code> + /// message Foo { + /// extensions 1000 to max + /// } + /// + /// extend Foo { + /// optional int32 bar; + /// } + /// </code> + /// Then MyProto.Foo.Bar has type GeneratedExtensionBase<MyProto.Foo,int>. + /// <para /> + /// In general, users should ignore the details of this type, and + /// simply use the static singletons as parameters to the extension accessors + /// in ExtendableMessage and ExtendableBuilder. + /// The interface implemented by both GeneratedException and GeneratedRepeatException, + /// to make it easier to cope with repeats separately. + /// </remarks> + public abstract class GeneratedExtensionBase<TExtension> { + + private readonly FieldDescriptor descriptor; + private readonly IMessage messageDefaultInstance; + + protected GeneratedExtensionBase(FieldDescriptor descriptor, Type singularExtensionType) { + if (!descriptor.IsExtension) { + throw new ArgumentException("GeneratedExtension given a regular (non-extension) field."); + } + + this.descriptor = descriptor; + if (descriptor.MappedType == MappedType.Message) { + PropertyInfo defaultInstanceProperty = singularExtensionType + .GetProperty("DefaultInstance", BindingFlags.Static | BindingFlags.Public); + if (defaultInstanceProperty == null) { + throw new ArgumentException("No public static DefaultInstance property for type " + typeof(TExtension).Name); + } + messageDefaultInstance = (IMessage)defaultInstanceProperty.GetValue(null, null); + } + } + + public FieldDescriptor Descriptor { + get { return descriptor; } + } + + /// <summary> + /// Returns the default message instance for extensions which are message types. + /// </summary> + public IMessage MessageDefaultInstance { + get { return messageDefaultInstance; } + } + + public object SingularFromReflectionType(object value) { + switch (Descriptor.MappedType) { + case MappedType.Message: + if (value is TExtension) { + return value; + } else { + // It seems the copy of the embedded message stored inside the + // extended message is not of the exact type the user was + // expecting. This can happen if a user defines a + // GeneratedExtension manually and gives it a different type. + // This should not happen in normal use. But, to be nice, we'll + // copy the message to whatever type the caller was expecting. + return MessageDefaultInstance.WeakCreateBuilderForType() + .WeakMergeFrom((IMessage)value).WeakBuild(); + } + case MappedType.Enum: + // Just return a boxed int - that can be unboxed to the enum + EnumValueDescriptor enumValue = (EnumValueDescriptor) value; + return enumValue.Number; + default: + return value; + } + } + + /// <summary> + /// Converts from the type used by the native accessors to the type + /// used by reflection accessors. For example, the reflection accessors + /// for enums use EnumValueDescriptors but the native accessors use + /// the generated enum type. + /// </summary> + public object ToReflectionType(object value) { + if (descriptor.IsRepeated) { + if (descriptor.MappedType == MappedType.Enum) { + // Must convert the whole list. + IList<object> result = new List<object>(); + foreach (object element in (IEnumerable) value) { + result.Add(SingularToReflectionType(element)); + } + return result; + } else { + return value; + } + } else { + return SingularToReflectionType(value); + } + } + + /// <summary> + /// Like ToReflectionType(object) but for a single element. + /// </summary> + internal Object SingularToReflectionType(object value) { + return descriptor.MappedType == MappedType.Enum + ? descriptor.EnumType.FindValueByNumber((int) value) + : value; + } + + public abstract object FromReflectionType(object value); + } +}
\ No newline at end of file diff --git a/src/ProtocolBuffers/GeneratedMessage.cs b/src/ProtocolBuffers/GeneratedMessage.cs new file mode 100644 index 00000000..7801d521 --- /dev/null +++ b/src/ProtocolBuffers/GeneratedMessage.cs @@ -0,0 +1,139 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Collections; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.FieldAccess; +using System.Collections; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// All generated protocol message classes extend this class. It implements + /// most of the IMessage interface using reflection. Users + /// can ignore this class as an implementation detail. + /// </summary> + public abstract class GeneratedMessage<TMessage, TBuilder> : AbstractMessage<TMessage, TBuilder> + where TMessage : GeneratedMessage<TMessage, TBuilder> + where TBuilder : GeneratedBuilder<TMessage, TBuilder> { + + private UnknownFieldSet unknownFields = UnknownFieldSet.DefaultInstance; + + /// <summary> + /// Returns the message as a TMessage. + /// </summary> + protected abstract TMessage ThisMessage { get; } + + internal FieldAccessorTable<TMessage, TBuilder> FieldAccessorsFromBuilder { + get { return InternalFieldAccessors; } + } + + protected abstract FieldAccessorTable<TMessage, TBuilder> InternalFieldAccessors { get; } + + public override MessageDescriptor DescriptorForType { + get { return InternalFieldAccessors.Descriptor; } + } + + internal IDictionary<FieldDescriptor, Object> GetMutableFieldMap() { + + // Use a SortedList so we'll end up serializing fields in order + var ret = new SortedList<FieldDescriptor, object>(); + MessageDescriptor descriptor = DescriptorForType; + foreach (FieldDescriptor field in descriptor.Fields) { + IFieldAccessor<TMessage, TBuilder> accessor = InternalFieldAccessors[field]; + if (field.IsRepeated) { + if (accessor.GetRepeatedCount(ThisMessage) != 0) { + ret[field] = accessor.GetValue(ThisMessage); + } + } else if (HasField(field)) { + ret[field] = accessor.GetValue(ThisMessage); + } + } + return ret; + } + + public override bool IsInitialized { + get { + /* if (!DescriptorForType.HasRequiredFields) { + return true; + }*/ + // Check that all required fields are present. + foreach (FieldDescriptor field in DescriptorForType.Fields) { + if (field.IsRequired && !HasField(field)) { + return false; + } + } + + // Check that embedded messages are initialized. + // This code is similar to that in AbstractMessage, but we don't + // fetch all the field values - just the ones we need to. + foreach (FieldDescriptor field in DescriptorForType.Fields) { + if (field.MappedType == MappedType.Message) { + if (field.IsRepeated) { + // We know it's an IList<T>, but not the exact type - so + // IEnumerable is the best we can do. (C# generics aren't covariant yet.) + foreach (IMessage element in (IEnumerable) this[field]) { + if (!element.IsInitialized) { + return false; + } + } + } else { + if (HasField(field) && !((IMessage) this[field]).IsInitialized) { + return false; + } + } + } + } + return true; + } + } + + public override IDictionary<FieldDescriptor, object> AllFields { + get { return Dictionaries.AsReadOnly(GetMutableFieldMap()); } + } + + public override bool HasField(FieldDescriptor field) { + return InternalFieldAccessors[field].Has(ThisMessage); + } + + public override int GetRepeatedFieldCount(FieldDescriptor field) { + return InternalFieldAccessors[field].GetRepeatedCount(ThisMessage); + } + + public override object this[FieldDescriptor field, int index] { + get { return InternalFieldAccessors[field].GetRepeatedValue(ThisMessage, index); } + } + + public override object this[FieldDescriptor field] { + get { return InternalFieldAccessors[field].GetValue(ThisMessage); } + } + + public override UnknownFieldSet UnknownFields { + get { return unknownFields; } + } + + /// <summary> + /// Replaces the set of unknown fields for this message. This should + /// only be used before a message is built, by the builder. (In the + /// Java code it is private, but the builder is nested so has access + /// to it.) + /// </summary> + internal void SetUnknownFields(UnknownFieldSet fieldSet) { + unknownFields = fieldSet; + } + } +} diff --git a/src/ProtocolBuffers/GeneratedRepeatExtension.cs b/src/ProtocolBuffers/GeneratedRepeatExtension.cs new file mode 100644 index 00000000..ae711bd2 --- /dev/null +++ b/src/ProtocolBuffers/GeneratedRepeatExtension.cs @@ -0,0 +1,57 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using Google.ProtocolBuffers.Descriptors; +using System.Collections; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Class used to represent repeat extensions in generated classes. + /// </summary> + public sealed class GeneratedRepeatExtension<TExtensionElement> : GeneratedExtensionBase<IList<TExtensionElement>> { + private GeneratedRepeatExtension(FieldDescriptor field) : base(field, typeof(TExtensionElement)) { + } + + public static GeneratedExtensionBase<IList<TExtensionElement>> CreateInstance(FieldDescriptor descriptor) { + if (!descriptor.IsRepeated) { + throw new ArgumentException("Must call GeneratedRepeatExtension.CreateInstance() for repeated types."); + } + return new GeneratedRepeatExtension<TExtensionElement>(descriptor); + } + + /// <summary> + /// Converts the list to the right type. + /// TODO(jonskeet): Check where this is used, and whether we need to convert + /// for primitive types. + /// </summary> + /// <param name="value"></param> + /// <returns></returns> + public override object FromReflectionType(object value) { + if (Descriptor.MappedType == MappedType.Message || + Descriptor.MappedType == MappedType.Enum) { + // Must convert the whole list. + List<TExtensionElement> result = new List<TExtensionElement>(); + foreach (object element in (IEnumerable) value) { + result.Add((TExtensionElement) SingularFromReflectionType(element)); + } + return result; + } else { + return value; + } + } + } +} diff --git a/src/ProtocolBuffers/GeneratedSingleExtension.cs b/src/ProtocolBuffers/GeneratedSingleExtension.cs new file mode 100644 index 00000000..55450f21 --- /dev/null +++ b/src/ProtocolBuffers/GeneratedSingleExtension.cs @@ -0,0 +1,39 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// Generated extension for a singular field. + /// </remarks> + public sealed class GeneratedSingleExtension<TExtension> : GeneratedExtensionBase<TExtension> { + internal GeneratedSingleExtension(FieldDescriptor descriptor) : base(descriptor, typeof(TExtension)) { + } + + public static GeneratedSingleExtension<TExtension> CreateInstance(FieldDescriptor descriptor) { + if (descriptor.IsRepeated) { + throw new ArgumentException("Must call GeneratedRepeateExtension.CreateInstance() for repeated types."); + } + return new GeneratedSingleExtension<TExtension>(descriptor); + } + + public override object FromReflectionType(object value) { + return base.SingularFromReflectionType(value); + } + } +} diff --git a/src/ProtocolBuffers/IBuilder.cs b/src/ProtocolBuffers/IBuilder.cs new file mode 100644 index 00000000..4100dedd --- /dev/null +++ b/src/ProtocolBuffers/IBuilder.cs @@ -0,0 +1,283 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.IO; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// Non-generic interface for all members whose signatures don't require knowledge of + /// the type being built. The generic interface extends this one. Some methods return + /// either an IBuilder or an IMessage; in these cases the generic interface redeclares + /// the same method with a type-specific signature. Implementations are encouraged to + /// use explicit interface implemenation for the non-generic form. This mirrors + /// how IEnumerable and IEnumerable<T> work. + /// </summary> + public interface IBuilder { + /// <summary> + /// Returns true iff all required fields in the message and all + /// embedded messages are set. + /// </summary> + bool IsInitialized { get; } + + /// <summary> + /// Only present in the nongeneric interface - useful for tests, but + /// not as much in real life. + /// </summary> + IBuilder SetField(FieldDescriptor field, object value); + + /// <summary> + /// Only present in the nongeneric interface - useful for tests, but + /// not as much in real life. + /// </summary> + IBuilder SetRepeatedField(FieldDescriptor field, int index, object value); + + /// <summary> + /// Behaves like the equivalent property in IMessage<T>. + /// The returned map may or may not reflect future changes to the builder. + /// Either way, the returned map is unmodifiable. + /// </summary> + IDictionary<FieldDescriptor, object> AllFields { get; } + + /// <summary> + /// Allows getting and setting of a field. + /// <see cref="IMessage{TMessage, TBuilder}.Item(FieldDescriptor)"/> + /// </summary> + /// <param name="field"></param> + /// <returns></returns> + object this[FieldDescriptor field] { get; set; } + + /// <summary> + /// Get the message's type descriptor. + /// <see cref="IMessage{TMessage, TBuilder}.DescriptorForType"/> + /// </summary> + MessageDescriptor DescriptorForType { get; } + + /// <summary> + /// <see cref="IMessage{TMessage, TBuilder}.GetRepeatedFieldCount"/> + /// </summary> + /// <param name="field"></param> + /// <returns></returns> + int GetRepeatedFieldCount(FieldDescriptor field); + + /// <summary> + /// Allows getting and setting of a repeated field value. + /// <see cref="IMessage{TMessage, TBuilder}.Item(FieldDescriptor, int)"/> + /// </summary> + object this[FieldDescriptor field, int index] { get; set; } + + /// <summary> + /// <see cref="IMessage{TMessage, TBuilder}.HasField"/> + /// </summary> + bool HasField(FieldDescriptor field); + + /// <summary> + /// <see cref="IMessage{TMessage, TBuilder}.UnknownFields"/> + /// </summary> + UnknownFieldSet UnknownFields { get; set; } + + /// <summary> + /// Create a builder for messages of the appropriate type for the given field. + /// Messages built with this can then be passed to the various mutation properties + /// and methods. + /// </summary> + IBuilder CreateBuilderForField(FieldDescriptor field); + + #region Methods which are like those of the generic form, but without any knowledge of the type parameters + IBuilder WeakAddRepeatedField(FieldDescriptor field, object value); + IBuilder WeakClear(); + IBuilder WeakClearField(FieldDescriptor field); + IBuilder WeakMergeFrom(IMessage message); + IBuilder WeakMergeFrom(ByteString data); + IBuilder WeakMergeFrom(ByteString data, ExtensionRegistry registry); + IBuilder WeakMergeFrom(CodedInputStream input); + IBuilder WeakMergeFrom(CodedInputStream input, ExtensionRegistry registry); + IMessage WeakBuild(); + IMessage WeakBuildPartial(); + IBuilder WeakClone(); + IMessage WeakDefaultInstanceForType { get; } + #endregion + } + + /// <summary> + /// Interface implemented by Protocol Message builders. + /// TODO(jonskeet): Consider "SetXXX" methods returning the builder, as well as the properties. + /// </summary> + /// <typeparam name="TMessage">Type of message</typeparam> + /// <typeparam name="TBuilder">Type of builder</typeparam> + public interface IBuilder<TMessage, TBuilder> : IBuilder + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + + TBuilder SetUnknownFields(UnknownFieldSet unknownFields); + + /// <summary> + /// Resets all fields to their default values. + /// </summary> + TBuilder Clear(); + + /// <summary> + /// Merge the specified other message into the message being + /// built. Merging occurs as follows. For each field: + /// For singular primitive fields, if the field is set in <paramref name="other"/>, + /// then <paramref name="other"/>'s value overwrites the value in this message. + /// For singular message fields, if the field is set in <paramref name="other"/>, + /// it is merged into the corresponding sub-message of this message using the same + /// merging rules. + /// For repeated fields, the elements in <paramref name="other"/> are concatenated + /// with the elements in this message. + /// </summary> + /// <param name="other"></param> + /// <returns></returns> + TBuilder MergeFrom(TMessage other); + + /// <summary> + /// Merge the specified other message which may be a different implementation of + /// the same message descriptor. + /// </summary> + TBuilder MergeFrom(IMessage other); + + /// <summary> + /// Constructs the final message. Once this is called, this Builder instance + /// is no longer valid, and calling any other method may throw a + /// NullReferenceException. If you need to continue working with the builder + /// after calling Build, call Clone first. + /// </summary> + /// <exception cref="UninitializedMessageException">the message + /// is missing one or more required fields; use BuildPartial to bypass + /// this check</exception> + TMessage Build(); + + /// <summary> + /// Like Build(), but does not throw an exception if the message is missing + /// required fields. Instead, a partial message is returned. + /// </summary> + TMessage BuildPartial(); + + /// <summary> + /// Clones this builder. + /// TODO(jonskeet): Explain depth of clone. + /// </summary> + TBuilder Clone(); + + /// <summary> + /// Parses a message of this type from the input and merges it with this + /// message, as if using MergeFrom(IMessage<T>). + /// </summary> + /// <remarks> + /// Warning: This does not verify that all required fields are present + /// in the input message. If you call Build() without setting all + /// required fields, it will throw an UninitializedMessageException. + /// There are a few good ways to deal with this: + /// <list> + /// <item>Call IsInitialized to verify to verify that all required fields are + /// set before building.</item> + /// <item>Parse the message separately using one of the static ParseFrom + /// methods, then use MergeFrom(IMessage<T>) to merge it with + /// this one. ParseFrom will throw an InvalidProtocolBufferException + /// (an IOException) if some required fields are missing. + /// Use BuildPartial to build, which ignores missing required fields. + /// </list> + /// </remarks> + TBuilder MergeFrom(CodedInputStream input); + + /// <summary> + /// Like MergeFrom(CodedInputStream), but also parses extensions. + /// The extensions that you want to be able to parse must be registered + /// in <paramref name="extensionRegistry"/>. Extensions not in the registry + /// will be treated as unknown fields. + /// </summary> + TBuilder MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry); + + /// <summary> + /// Get's the message's type's default instance. + /// <see cref="IMessage{TMessage}.DefaultInstanceForType" /> + /// </summary> + TMessage DefaultInstanceForType { get; } + + /// <summary> + /// Clears the field. This is exactly equivalent to calling the generated + /// Clear method corresponding to the field. + /// </summary> + /// <param name="field"></param> + /// <returns></returns> + TBuilder ClearField(FieldDescriptor field); + + /// <summary> + /// Appends the given value as a new element for the specified repeated field. + /// </summary> + /// <exception cref="ArgumentException">the field is not a repeated field, + /// the field does not belong to this builder's type, or the value is + /// of the incorrect type + /// </exception> + TBuilder AddRepeatedField(FieldDescriptor field, object value); + + /// <summary> + /// Merge some unknown fields into the set for this message. + /// </summary> + TBuilder MergeUnknownFields(UnknownFieldSet unknownFields); + + #region Convenience methods + /// <summary> + /// Parse <paramref name="data"/> as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream). + /// </summary> + TBuilder MergeFrom(ByteString data); + + /// <summary> + /// Parse <paramref name="data"/> as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream, ExtensionRegistry). + /// </summary> + TBuilder MergeFrom(ByteString data, ExtensionRegistry extensionRegistry); + + /// <summary> + /// Parse <paramref name="data"/> as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream). + /// </summary> + TBuilder MergeFrom(byte[] data); + + /// <summary> + /// Parse <paramref name="data"/> as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream, ExtensionRegistry). + /// </summary> + TBuilder MergeFrom(byte[] data, ExtensionRegistry extensionRegistry); + + /// <summary> + /// Parse <paramref name="input"/> as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream). Note that this method always reads + /// the entire input (unless it throws an exception). If you want it to + /// stop earlier, you will need to wrap the input in a wrapper + /// stream which limits reading. Despite usually reading the entire + /// stream, this method never closes the stream. + /// </summary> + TBuilder MergeFrom(Stream input); + + /// <summary> + /// Parse <paramref name="input"/> as a message of this type and merge + /// it with the message being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream, ExtensionRegistry). + /// </summary> + TBuilder MergeFrom(Stream input, ExtensionRegistry extensionRegistry); + #endregion + } +} diff --git a/src/ProtocolBuffers/IMessage.cs b/src/ProtocolBuffers/IMessage.cs new file mode 100644 index 00000000..1ce18a5c --- /dev/null +++ b/src/ProtocolBuffers/IMessage.cs @@ -0,0 +1,186 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.IO; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// Non-generic interface used for all parts of the API which don't require + /// any type knowledge. + /// </summary> + public interface IMessage { + /// <summary> + /// Returns the message's type's descriptor. This differs from the + /// Descriptor property of each generated message class in that this + /// method is an abstract method of IMessage whereas Descriptor is + /// a static property of a specific class. They return the same thing. + /// </summary> + MessageDescriptor DescriptorForType { get; } + /// <summary> + /// Returns a collection of all the fields in this message which are set + /// and their corresponding values. A singular ("required" or "optional") + /// field is set iff HasField() returns true for that field. A "repeated" + /// field is set iff GetRepeatedFieldSize() is greater than zero. The + /// values are exactly what would be returned by calling + /// GetField(FieldDescriptor) for each field. The map + /// is guaranteed to be a sorted map, so iterating over it will return fields + /// in order by field number. + /// </summary> + IDictionary<FieldDescriptor, object> AllFields { get; } + + /// <summary> + /// Returns true if the given field is set. This is exactly equivalent + /// to calling the generated "Has" property corresponding to the field. + /// </summary> + /// <exception cref="ArgumentException">the field is a repeated field, + /// or it's not a field of this type</exception> + bool HasField(FieldDescriptor field); + + /// <summary> + /// Obtains the value of the given field, or the default value if + /// it isn't set. For value type fields, the boxed value is returned. + /// For enum fields, the EnumValueDescriptor for the enum is returned. + /// For embedded message fields, the sub-message + /// is returned. For repeated fields, an IList<T> is returned. + /// </summary> + object this[FieldDescriptor field] { get; } + + /// <summary> + /// Returns the number of elements of a repeated field. This is + /// exactly equivalent to calling the generated "Count" property + /// corresponding to the field. + /// </summary> + /// <exception cref="ArgumentException">the field is not a repeated field, + /// or it's not a field of this type</exception> + int GetRepeatedFieldCount(FieldDescriptor field); + + /// <summary> + /// Gets an element of a repeated field. For value type fields + /// including enums, the boxed value is returned. For embedded + /// message fields, the sub-message is returned. + /// </summary> + /// <exception cref="ArgumentException">the field is not a repeated field, + /// or it's not a field of this type</exception> + /// <exception cref="ArgumentOutOfRangeException">the index is out of + /// range for the repeated field's value</exception> + object this[FieldDescriptor field, int index] { get; } + + /// <summary> + /// Returns the unknown fields for this message. + /// </summary> + UnknownFieldSet UnknownFields { get; } + + /// <summary> + /// Returns true iff all required fields in the message and all embedded + /// messages are set. + /// </summary> + bool IsInitialized { get; } + + /// <summary> + /// Serializes the message and writes it to the given output stream. + /// This does not flush or close the stream. + /// </summary> + /// <param name="output"></param> + void WriteTo(CodedOutputStream output); + + /// <summary> + /// Returns the number of bytes required to encode this message. + /// The result is only computed on the first call and memoized after that. + /// </summary> + int SerializedSize { get; } + + #region Comparison and hashing + /// <summary> + /// Compares the specified object with this message for equality. + /// Returns true iff the given object is a message of the same type + /// (as defined by DescriptorForType) and has identical values + /// for all its fields. + /// </summary> + bool Equals(object other); + + /// <summary> + /// Returns the hash code value for this message. + /// TODO(jonskeet): Specify the hash algorithm, but better than the Java one! + /// </summary> + int GetHashCode(); + #endregion + + #region Convenience methods + /// <summary> + /// Converts the message to a string in protocol buffer text format. + /// This is just a trivial wrapper around TextFormat.PrintToString. + /// </summary> + string ToString(); + + /// <summary> + /// Serializes the message to a ByteString. This is a trivial wrapper + /// around WriteTo(CodedOutputStream). + /// </summary> + ByteString ToByteString(); + + /// <summary> + /// Serializes the message to a byte array. This is a trivial wrapper + /// around WriteTo(CodedOutputStream). + /// </summary> + byte[] ToByteArray(); + + /// <summary> + /// Serializes the message and writes it to the given stream. + /// This is just a wrapper around WriteTo(CodedOutputStream). This + /// does not flush or close the stream. + /// </summary> + /// <param name="output"></param> + void WriteTo(Stream output); + #endregion + + /// <summary> + /// Creates a builder for the type, but in a weakly typed manner. This + /// is typically implemented by strongly typed builders by just returning + /// the result of CreateBuilderForType. + /// </summary> + IBuilder WeakCreateBuilderForType(); + + IMessage WeakDefaultInstanceForType { get; } + } + + public interface IMessage<TMessage> : IMessage { + /// <summary> + /// Returns an instance of this message type with all fields set to + /// their default values. This may or may not be a singleton. This differs + /// from the DefaultInstance property of each generated message class in that this + /// method is an abstract method of IMessage whereas DefaultInstance is + /// a static property of a specific class. They return the same thing. + /// </summary> + TMessage DefaultInstanceForType { get; } + } + + /// <summary> + /// Type-safe interface for all generated messages to implement. + /// </summary> + public interface IMessage<TMessage, TBuilder> : IMessage<TMessage> + where TMessage : IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + #region Builders + /// <summary> + /// Constructs a new builder for a message of the same type as this message. + /// </summary> + TBuilder CreateBuilderForType(); + #endregion + } +} diff --git a/src/ProtocolBuffers/IRpcChannel.cs b/src/ProtocolBuffers/IRpcChannel.cs new file mode 100644 index 00000000..59427835 --- /dev/null +++ b/src/ProtocolBuffers/IRpcChannel.cs @@ -0,0 +1,40 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Interface for an RPC channel. A channel represents a communication line to + /// a service (IService implementation) which can be used to call that service's + /// methods. The service may be running on another machine. Normally, you should + /// not call an IRpcChannel directly, but instead construct a stub wrapping it. + /// Generated service classes contain a CreateStub method for precisely this purpose. + /// </summary> + public interface IRpcChannel { + /// <summary> + /// Calls the given method of the remote service. This method is similar + /// to <see cref="IService.CallMethod" /> with one important difference: the + /// caller decides the types of the IMessage objects, not the implementation. + /// The request may be of any type as long as <c>request.Descriptor == method.InputType</c>. + /// The response passed to the callback will be of the same type as + /// <paramref name="responsePrototype"/> (which must be such that + /// <c>responsePrototype.Descriptor == method.OutputType</c>). + /// </summary> + void CallMethod(MethodDescriptor method, IRpcController controller, + IMessage request, IMessage responsePrototype, Action<IMessage> done); + } +} diff --git a/src/ProtocolBuffers/IRpcController.cs b/src/ProtocolBuffers/IRpcController.cs new file mode 100644 index 00000000..88cef2db --- /dev/null +++ b/src/ProtocolBuffers/IRpcController.cs @@ -0,0 +1,99 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Mediates a single method call. The primary purpose of the controller + /// is to provide a way to manipulate settings specific to the + /// RPC implementation and to find out about RPC-level errors. + /// + /// The methods provided by this interface are intended to be a "least + /// common denominator" set of features which we expect all implementations to + /// support. Specific implementations may provide more advanced features, + /// (e.g. deadline propagation). + /// </summary> + public interface IRpcController { + + #region Client side calls + // These calls may be made from the client side only. Their results + // are undefined on the server side (may throw exceptions). + + /// <summary> + /// Resets the controller to its initial state so that it may be reused in + /// a new call. This can be called from the client side only. It must not + /// be called while an RPC is in progress. + /// </summary> + void Reset(); + + /// <summary> + /// After a call has finished, returns true if the call failed. The possible + /// reasons for failure depend on the RPC implementation. Failed must + /// only be called on the client side, and must not be called before a call has + /// finished. + /// </summary> + bool Failed { get; } + + /// <summary> + /// If Failed is true, ErrorText returns a human-readable description of the error. + /// </summary> + string ErrorText { get; } + + /// <summary> + /// Advises the RPC system that the caller desires that the RPC call be + /// canceled. The RPC system may cancel it immediately, may wait awhile and + /// then cancel it, or may not even cancel the call at all. If the call is + /// canceled, the "done" callback will still be called and the RpcController + /// will indicate that the call failed at that time. + /// </summary> + void StartCancel(); + #endregion + + #region Server side calls + // These calls may be made from the server side only. Their results + // are undefined on the client side (may throw exceptions). + + /// <summary> + /// Causes Failed to return true on the client side. <paramref name="reason"/> + /// will be incorporated into the message returned by ErrorText. + /// If you find you need to return machine-readable information about + /// failures, you should incorporate it into your response protocol buffer + /// and should *not* call SetFailed. + /// </summary> + void SetFailed(string reason); + + /// <summary> + /// If true, indicates that the client canceled the RPC, so the server may as + /// well give up on replying to it. This method must be called on the server + /// side only. The server should still call the final "done" callback. + /// </summary> + bool isCanceled(); + + /// <summary> + /// Requests that the given callback be called when the RPC is canceled. + /// The parameter passed to the callback will always be null. The callback will + /// be called exactly once. If the RPC completes without being canceled, the + /// callback will be called after completion. If the RPC has already been canceled + /// when NotifyOnCancel is called, the callback will be called immediately. + /// + /// NotifyOnCancel must be called no more than once per request. It must be + /// called on the server side only. + /// </summary> + /// <param name="callback"></param> + void NotifyOnCancel(Action<object> callback); + #endregion + } +} diff --git a/src/ProtocolBuffers/IService.cs b/src/ProtocolBuffers/IService.cs new file mode 100644 index 00000000..4bf1e352 --- /dev/null +++ b/src/ProtocolBuffers/IService.cs @@ -0,0 +1,79 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Base interface for protocol-buffer-based RPC services. Services themselves + /// are abstract classes (implemented either by servers or as stubs) but they + /// implement this itnerface. The methods of this interface can be used to call + /// the methods of the service without knowing its exact type at compile time + /// (analagous to the IMessage interface). + /// </summary> + public interface IService { + /// <summary> + /// The ServiceDescriptor describing this service and its methods. + /// </summary> + ServiceDescriptor DescriptorForType { get; } + + /// <summary> + /// Call a method of the service specified by MethodDescriptor. This is + /// normally implemented as a simple switch that calls the standard + /// definitions of the service's methods. + /// <para> + /// Preconditions + /// <list> + /// <item><c>method.Service == DescriptorForType</c></item> + /// <item>request is of the exact same class as the object returned by GetRequestPrototype(method)</item> + /// <item>controller is of the correct type for the RPC implementation being used by this service. + /// For stubs, the "correct type" depends on the IRpcChannel which the stub is using. Server-side + /// implementations are expected to accept whatever type of IRpcController the server-side RPC implementation + /// uses.</item> + /// </list> + /// </para> + /// <para> + /// Postconditions + /// <list> + /// <item><paramref name="done" /> will be called when the method is complete. + /// This may before CallMethod returns or it may be at some point in the future.</item> + /// <item>The parameter to <paramref name="done"/> is the response. It will be of the + /// exact same type as would be returned by <see cref="GetResponsePrototype"/>.</item> + /// <item>If the RPC failed, the parameter to <paramref name="done"/> will be null. + /// Further details about the failure can be found by querying <paramref name="controller"/>.</item> + /// </list> + /// </para> + /// </summary> + void CallMethod(MethodDescriptor method, IRpcController controller, + IMessage request, Action<IMessage> done); + + /// <summary> + /// CallMethod requires that the request passed in is of a particular implementation + /// of IMessage. This method gets the default instance of this type of a given method. + /// You can then call WeakCreateBuilderForType to create a builder to build an object which + /// you can then pass to CallMethod. + /// </summary> + IMessage GetRequestPrototype(MethodDescriptor method); + + /// <summary> + /// Like GetRequestPrototype, but returns a prototype of the response message. + /// This is generally not needed because the IService implementation contructs + /// the response message itself, but it may be useful in some cases to know ahead + /// of time what type of object will be returned. + /// </summary> + IMessage GetResponsePrototype(MethodDescriptor method); + } +} diff --git a/src/ProtocolBuffers/InvalidProtocolBufferException.cs b/src/ProtocolBuffers/InvalidProtocolBufferException.cs new file mode 100644 index 00000000..4f1b1a92 --- /dev/null +++ b/src/ProtocolBuffers/InvalidProtocolBufferException.cs @@ -0,0 +1,80 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.IO; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Thrown when a protocol message being parsed is invalid in some way, + /// e.g. it contains a malformed varint or a negative byte length. + /// </summary> + public sealed class InvalidProtocolBufferException : IOException { + + internal InvalidProtocolBufferException(string message) + : base(message) { + } + + internal static InvalidProtocolBufferException TruncatedMessage() { + return new InvalidProtocolBufferException( + "While parsing a protocol message, the input ended unexpectedly " + + "in the middle of a field. This could mean either than the " + + "input has been truncated or that an embedded message " + + "misreported its own length."); + } + + internal static InvalidProtocolBufferException NegativeSize() { + return new InvalidProtocolBufferException( + "CodedInputStream encountered an embedded string or message " + + "which claimed to have negative size."); + } + + public static InvalidProtocolBufferException MalformedVarint() { + return new InvalidProtocolBufferException( + "CodedInputStream encountered a malformed varint."); + } + + internal static InvalidProtocolBufferException InvalidTag() { + return new InvalidProtocolBufferException( + "Protocol message contained an invalid tag (zero)."); + } + + internal static InvalidProtocolBufferException InvalidEndTag() { + return new InvalidProtocolBufferException( + "Protocol message end-group tag did not match expected tag."); + } + + internal static InvalidProtocolBufferException InvalidWireType() { + return new InvalidProtocolBufferException( + "Protocol message tag had invalid wire type."); + } + + internal static InvalidProtocolBufferException RecursionLimitExceeded() { + return new InvalidProtocolBufferException( + "Protocol message had too many levels of nesting. May be malicious. " + + "Use CodedInputStream.SetRecursionLimit() to increase the depth limit."); + } + + internal static InvalidProtocolBufferException SizeLimitExceeded() { + return new InvalidProtocolBufferException( + "Protocol message was too large. May be malicious. " + + "Use CodedInputStream.SetSizeLimit() to increase the size limit."); + } + + internal static InvalidProtocolBufferException InvalidMessageStreamTag() { + return new InvalidProtocolBufferException( + "Stream of protocol messages had invalid tag. Expected tag is length-delimited field 1."); + } + } +} diff --git a/src/ProtocolBuffers/MessageStreamIterator.cs b/src/ProtocolBuffers/MessageStreamIterator.cs new file mode 100644 index 00000000..61dbf840 --- /dev/null +++ b/src/ProtocolBuffers/MessageStreamIterator.cs @@ -0,0 +1,150 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; +using System.IO; +using System.Reflection; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// Iterates over data created using a <see cref="MessageStreamWriter{T}" />. + /// Unlike MessageStreamWriter, this class is not usually constructed directly with + /// a stream; instead it is provided with a way of opening a stream when iteration + /// is started. The stream is closed when the iteration is completed or the enumerator + /// is disposed. (This occurs naturally when using <c>foreach</c>.) + /// </summary> + public class MessageStreamIterator<TMessage> : IEnumerable<TMessage> + where TMessage : IMessage<TMessage> { + + private readonly StreamProvider streamProvider; + private readonly ExtensionRegistry extensionRegistry; + + /// <summary> + /// Delegate created via reflection trickery (once per type) to create a builder + /// and read a message from a CodedInputStream with it. Note that unlike in Java, + /// there's one static field per constructed type. + /// </summary> + private static readonly Func<CodedInputStream, ExtensionRegistry, TMessage> messageReader = BuildMessageReader(); + + /// <summary> + /// Any exception (within reason) thrown within messageReader is caught and rethrown in the constructor. + /// This makes life a lot simpler for the caller. + /// </summary> + private static Exception typeInitializationException; + + /// <summary> + /// Creates the delegate later used to read messages. This is only called once per type, but to + /// avoid exceptions occurring at confusing times, if this fails it will set typeInitializationException + /// to the appropriate error and return null. + /// </summary> + private static Func<CodedInputStream, ExtensionRegistry, TMessage> BuildMessageReader() { + try { + Type builderType = FindBuilderType(); + + // Yes, it's redundant to find this again, but it's only the once... + MethodInfo createBuilderMethod = typeof(TMessage).GetMethod("CreateBuilder", Type.EmptyTypes); + Delegate builderBuilder = Delegate.CreateDelegate( + typeof(Func<>).MakeGenericType(builderType), null, createBuilderMethod); + + MethodInfo buildMethod = typeof(MessageStreamIterator<TMessage>) + .GetMethod("BuildImpl", BindingFlags.Static | BindingFlags.NonPublic) + .MakeGenericMethod(typeof(TMessage), builderType); + + return (Func<CodedInputStream, ExtensionRegistry, TMessage>)Delegate.CreateDelegate( + typeof(Func<CodedInputStream, ExtensionRegistry, TMessage>), builderBuilder, buildMethod); + } catch (ArgumentException e) { + typeInitializationException = e; + } catch (InvalidOperationException e) { + typeInitializationException = e; + } catch (InvalidCastException e) { + // Can't see why this would happen, but best to know about it. + typeInitializationException = e; + } + return null; + } + + /// <summary> + /// Works out the builder type for TMessage, or throws an ArgumentException to explain why it can't. + /// This will check + /// </summary> + private static Type FindBuilderType() { + MethodInfo createBuilderMethod = typeof(TMessage).GetMethod("CreateBuilder", Type.EmptyTypes); + if (createBuilderMethod == null) { + throw new ArgumentException("Message type " + typeof(TMessage).FullName + " has no CreateBuilder method."); + } + if (createBuilderMethod.ReturnType == typeof(void)) { + throw new ArgumentException("CreateBuilder method in " + typeof(TMessage).FullName + " has void return type"); + } + Type builderType = createBuilderMethod.ReturnType; + Type messageInterface = typeof(IMessage<,>).MakeGenericType(typeof(TMessage), builderType); + Type builderInterface = typeof(IBuilder<,>).MakeGenericType(typeof(TMessage), builderType); + if (Array.IndexOf(typeof(TMessage).GetInterfaces(), messageInterface) == -1) { + throw new ArgumentException("Message type " + typeof(TMessage) + " doesn't implement " + messageInterface.FullName); + } + if (Array.IndexOf(builderType.GetInterfaces(), builderInterface) == -1) { + throw new ArgumentException("Builder type " + typeof(TMessage) + " doesn't implement " + builderInterface.FullName); + } + return builderType; + } + + /// <summary> + /// Method we'll use to build messageReader, with the first parameter fixed to TMessage.CreateBuilder. Note that we + /// have to introduce another type parameter (TMessage2) as we can't constrain TMessage for just a single method + /// (and we can't do it at the type level because we don't know TBuilder). However, by constraining TMessage2 + /// to not only implement IMessage appropriately but also to derive from TMessage2, we can avoid doing a cast + /// for every message; the implicit reference conversion will be fine. In practice, TMessage2 and TMessage will + /// be the same type when we construct the generic method by reflection. + /// </summary> + private static TMessage BuildImpl<TMessage2, TBuilder>(Func<TBuilder> builderBuilder, CodedInputStream input, ExtensionRegistry registry) + where TBuilder : IBuilder<TMessage2, TBuilder> + where TMessage2 : TMessage, IMessage<TMessage2, TBuilder> { + TBuilder builder = builderBuilder(); + input.ReadMessage(builder, registry); + return builder.Build(); + } + + private static readonly uint ExpectedTag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); + + private MessageStreamIterator(StreamProvider streamProvider, ExtensionRegistry extensionRegistry) { + if (messageReader == null) { + throw typeInitializationException; + } + this.streamProvider = streamProvider; + this.extensionRegistry = extensionRegistry; + } + + /// <summary> + /// Creates a new instance which uses the same stream provider as this one, + /// but the specified extension registry. + /// </summary> + public MessageStreamIterator<TMessage> WithExtensionRegistry(ExtensionRegistry newRegistry) { + return new MessageStreamIterator<TMessage>(streamProvider, newRegistry); + } + + public static MessageStreamIterator<TMessage> FromFile(string file) { + return new MessageStreamIterator<TMessage>(() => File.OpenRead(file), ExtensionRegistry.Empty); + } + + public static MessageStreamIterator<TMessage> FromStreamProvider(StreamProvider streamProvider) { + return new MessageStreamIterator<TMessage>(streamProvider, ExtensionRegistry.Empty); + } + + public IEnumerator<TMessage> GetEnumerator() { + using (Stream stream = streamProvider()) { + CodedInputStream input = CodedInputStream.CreateInstance(stream); + uint tag; + while ((tag = input.ReadTag()) != 0) { + if (tag != ExpectedTag) { + throw InvalidProtocolBufferException.InvalidMessageStreamTag(); + } + yield return messageReader(input, extensionRegistry); + } + } + } + + IEnumerator IEnumerable.GetEnumerator() { + return GetEnumerator(); + } + } +} diff --git a/src/ProtocolBuffers/MessageStreamWriter.cs b/src/ProtocolBuffers/MessageStreamWriter.cs new file mode 100644 index 00000000..9ff33b05 --- /dev/null +++ b/src/ProtocolBuffers/MessageStreamWriter.cs @@ -0,0 +1,33 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.IO; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Writes multiple messages to the same stream. Each message is written + /// as if it were an element of a repeated field 1 in a larger protocol buffer. + /// This class takes no ownership of the stream it is given; it never closes the + /// stream. + /// </summary> + public sealed class MessageStreamWriter<T> where T : IMessage<T> { + + private readonly CodedOutputStream codedOutput; + + /// <summary> + /// Creates an instance which writes to the given stream. + /// </summary> + /// <param name="output">Stream to write messages to.</param> + public MessageStreamWriter(Stream output) { + codedOutput = CodedOutputStream.CreateInstance(output); + } + + public void Write(T message) { + codedOutput.WriteMessage(1, message); + } + + public void Flush() { + codedOutput.Flush(); + } + } +} diff --git a/src/ProtocolBuffers/Properties/AssemblyInfo.cs b/src/ProtocolBuffers/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..749a2e45 --- /dev/null +++ b/src/ProtocolBuffers/Properties/AssemblyInfo.cs @@ -0,0 +1,63 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Reflection; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ProtocolBuffers")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ProtocolBuffers")] +[assembly: AssemblyCopyright("Copyright © 2008")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("279b643d-70e8-47ae-9eb1-500d1c48bab6")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] + +[assembly:InternalsVisibleTo("Google.ProtocolBuffers.Test,PublicKey="+ +"00240000048000009400000006020000002400005253413100040000010001008179f2dd31a648"+ +"2a2359dbe33e53701167a888e7c369a9ae3210b64f93861d8a7d286447e58bc167e3d99483beda"+ +"72f738140072bb69990bc4f98a21365de2c105e848974a3d210e938b0a56103c0662901efd6b78"+ +"0ee6dbe977923d46a8fda18fb25c65dd73b149a5cd9f3100668b56649932dadd8cf5be52eb1dce"+ +"ad5cedbf")] +[assembly: InternalsVisibleTo("ProtoGen,PublicKey=" + +"00240000048000009400000006020000002400005253413100040000010001006d739020e13bdc" + +"038e86fa8aa5e1b13aae65d3ae79d622816c6067ab5b6955be50cc887130117582349208c13a55" + +"5e09a6084558f989ccde66094f07822808d3a9b922b0e85b912070032e90bb35360be7efb7982b" + +"702d7a5c6ed1e21d8ca587b4f4c9d2b81210d3641cc75f506cdfc628ac5453ff0a6886986c981d" + +"12245bc7")] diff --git a/src/ProtocolBuffers/Properties/Google.ProtocolBuffers.snk b/src/ProtocolBuffers/Properties/Google.ProtocolBuffers.snk Binary files differnew file mode 100644 index 00000000..6bbfc90f --- /dev/null +++ b/src/ProtocolBuffers/Properties/Google.ProtocolBuffers.snk diff --git a/src/ProtocolBuffers/ProtocolBuffers.csproj b/src/ProtocolBuffers/ProtocolBuffers.csproj new file mode 100644 index 00000000..3f76aa7f --- /dev/null +++ b/src/ProtocolBuffers/ProtocolBuffers.csproj @@ -0,0 +1,121 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <ProductVersion>9.0.30729</ProductVersion> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</ProjectGuid> + <OutputType>Library</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>Google.ProtocolBuffers</RootNamespace> + <AssemblyName>Google.ProtocolBuffers</AssemblyName> + <TargetFrameworkVersion>v2.0</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + <SignAssembly>true</SignAssembly> + <AssemblyOriginatorKeyFile>Properties\Google.ProtocolBuffers.snk</AssemblyOriginatorKeyFile> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <ItemGroup> + <Reference Include="System" /> + <Reference Include="System.Data" /> + <Reference Include="System.Xml" /> + </ItemGroup> + <ItemGroup> + <Compile Include="AbstractBuilder.cs" /> + <Compile Include="AbstractMessage.cs" /> + <Compile Include="ByteString.cs" /> + <Compile Include="Collections\PopsicleList.cs" /> + <Compile Include="Delegates.cs" /> + <Compile Include="CodedInputStream.cs" /> + <Compile Include="CodedOutputStream.cs" /> + <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" /> + <Compile Include="Descriptors\DescriptorBase.cs" /> + <Compile Include="Descriptors\DescriptorPool.cs" /> + <Compile Include="Descriptors\DescriptorUtil.cs" /> + <Compile Include="Descriptors\DescriptorValidationException.cs" /> + <Compile Include="Descriptors\EnumDescriptor.cs" /> + <Compile Include="Descriptors\EnumValueDescriptor.cs" /> + <Compile Include="Descriptors\FieldDescriptor.cs" /> + <Compile Include="Descriptors\FieldMappingAttribute.cs" /> + <Compile Include="Descriptors\FieldType.cs" /> + <Compile Include="Descriptors\FileDescriptor.cs" /> + <Compile Include="Descriptors\IDescriptor.cs" /> + <Compile Include="Descriptors\IndexedDescriptorBase.cs" /> + <Compile Include="Descriptors\MappedType.cs" /> + <Compile Include="Descriptors\MessageDescriptor.cs" /> + <Compile Include="Descriptors\MethodDescriptor.cs" /> + <Compile Include="Descriptors\PackageDescriptor.cs" /> + <Compile Include="Descriptors\ServiceDescriptor.cs" /> + <Compile Include="DynamicMessage.cs" /> + <Compile Include="ExtendableBuilder.cs" /> + <Compile Include="ExtendableMessage.cs" /> + <Compile Include="ExtensionInfo.cs" /> + <Compile Include="ExtensionRegistry.cs" /> + <Compile Include="FieldAccess\ReflectionUtil.cs" /> + <Compile Include="FieldAccess\SingleEnumAccessor.cs" /> + <Compile Include="FieldAccess\SingleMessageAccessor.cs" /> + <Compile Include="FieldAccess\SinglePrimitiveAccessor.cs" /> + <Compile Include="FieldAccess\RepeatedPrimitiveAccessor.cs" /> + <Compile Include="FieldAccess\RepeatedEnumAccessor.cs" /> + <Compile Include="FieldAccess\IFieldAccessor.cs" /> + <Compile Include="FieldAccess\FieldAccessorTable.cs" /> + <Compile Include="FieldAccess\RepeatedMessageAccessor.cs" /> + <Compile Include="FieldSet.cs" /> + <Compile Include="GeneratedBuilder.cs" /> + <Compile Include="GeneratedRepeatExtension.cs" /> + <Compile Include="GeneratedSingleExtension.cs" /> + <Compile Include="GeneratedMessage.cs" /> + <Compile Include="IBuilder.cs" /> + <Compile Include="GeneratedExtensionBase.cs" /> + <Compile Include="IMessage.cs" /> + <Compile Include="InvalidProtocolBufferException.cs" /> + <Compile Include="IRpcChannel.cs" /> + <Compile Include="IRpcController.cs" /> + <Compile Include="IService.cs" /> + <Compile Include="MessageStreamIterator.cs" /> + <Compile Include="MessageStreamWriter.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + <Compile Include="RpcUtil.cs" /> + <Compile Include="TextFormat.cs" /> + <Compile Include="TextGenerator.cs" /> + <Compile Include="TextTokenizer.cs" /> + <Compile Include="UninitializedMessageException.cs" /> + <Compile Include="UnknownField.cs" /> + <Compile Include="UnknownFieldSet.cs" /> + <Compile Include="WireFormat.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="Properties\Google.ProtocolBuffers.snk" /> + </ItemGroup> + <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> + <!-- To modify your build process, add your task inside one of the targets below and uncomment it. + Other similar extension points exist, see Microsoft.Common.targets. + <Target Name="BeforeBuild"> + </Target> + <Target Name="AfterBuild"> + </Target> + --> +</Project>
\ No newline at end of file diff --git a/src/ProtocolBuffers/RpcUtil.cs b/src/ProtocolBuffers/RpcUtil.cs new file mode 100644 index 00000000..bf383b45 --- /dev/null +++ b/src/ProtocolBuffers/RpcUtil.cs @@ -0,0 +1,52 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Grab-bag of utility functions useful when dealing with RPCs. + /// </summary> + public static class RpcUtil { + + /// <summary> + /// Converts an Action[IMessage] to an Action[T]. + /// </summary> + public static Action<T> SpecializeCallback<T>(Action<IMessage> action) + where T : IMessage<T> { + return message => action(message); + } + + /// <summary> + /// Converts an Action[T] to an Action[IMessage]. + /// The generalized action will accept any message object which has + /// the same descriptor, and will convert it to the correct class + /// before calling the original action. However, if the generalized + /// callback is given a message with a different descriptor, an + /// exception will be thrown. + /// </summary> + public static Action<IMessage> GeneralizeCallback<TMessage, TBuilder>(Action<TMessage> action, TMessage defaultInstance) + where TMessage : class, IMessage<TMessage, TBuilder> + where TBuilder : IBuilder<TMessage, TBuilder> { + return message => { + TMessage castMessage = message as TMessage; + if (castMessage == null) { + castMessage = defaultInstance.CreateBuilderForType().MergeFrom(message).Build(); + } + action(castMessage); + }; + } + } +} diff --git a/src/ProtocolBuffers/TextFormat.cs b/src/ProtocolBuffers/TextFormat.cs new file mode 100644 index 00000000..d487bd61 --- /dev/null +++ b/src/ProtocolBuffers/TextFormat.cs @@ -0,0 +1,620 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Text; +using Google.ProtocolBuffers.Descriptors; +using System.Collections; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Provides ASCII text formatting support for messages. + /// TODO(jonskeet): Parsing support. + /// </summary> + public static class TextFormat { + + /// <summary> + /// Outputs a textual representation of the Protocol Message supplied into + /// the parameter output. + /// </summary> + public static void Print(IMessage message, TextWriter output) { + TextGenerator generator = new TextGenerator(output); + Print(message, generator); + } + + /// <summary> + /// Outputs a textual representation of <paramref name="fields" /> to <paramref name="output"/>. + /// </summary> + public static void Print(UnknownFieldSet fields, TextWriter output) { + TextGenerator generator = new TextGenerator(output); + PrintUnknownFields(fields, generator); + } + + public static string PrintToString(IMessage message) { + StringWriter text = new StringWriter(); + Print(message, text); + return text.ToString(); + } + + public static string PrintToString(UnknownFieldSet fields) { + StringWriter text = new StringWriter(); + Print(fields, text); + return text.ToString(); + } + + private static void Print(IMessage message, TextGenerator generator) { + foreach (KeyValuePair<FieldDescriptor, object> entry in message.AllFields) { + PrintField(entry.Key, entry.Value, generator); + } + PrintUnknownFields(message.UnknownFields, generator); + } + + internal static void PrintField(FieldDescriptor field, object value, TextGenerator generator) { + if (field.IsRepeated) { + // Repeated field. Print each element. + foreach (object element in (IEnumerable) value) { + PrintSingleField(field, element, generator); + } + } else { + PrintSingleField(field, value, generator); + } + } + + private static void PrintSingleField(FieldDescriptor field, Object value, TextGenerator generator) { + if (field.IsExtension) { + generator.Print("["); + // We special-case MessageSet elements for compatibility with proto1. + if (field.ContainingType.Options.MessageSetWireFormat + && field.FieldType == FieldType.Message + && field.IsOptional + // object equality (TODO(jonskeet): Work out what this comment means!) + && field.ExtensionScope == field.MessageType) { + generator.Print(field.MessageType.FullName); + } else { + generator.Print(field.FullName); + } + generator.Print("]"); + } else { + if (field.FieldType == FieldType.Group) { + // Groups must be serialized with their original capitalization. + generator.Print(field.MessageType.Name); + } else { + generator.Print(field.Name); + } + } + + if (field.MappedType == MappedType.Message) { + generator.Print(" {\n"); + generator.Indent(); + } else { + generator.Print(": "); + } + + PrintFieldValue(field, value, generator); + + if (field.MappedType == MappedType.Message) { + generator.Outdent(); + generator.Print("}"); + } + generator.Print("\n"); + } + + private static void PrintFieldValue(FieldDescriptor field, object value, TextGenerator generator) { + switch (field.FieldType) { + case FieldType.Int32: + case FieldType.Int64: + case FieldType.SInt32: + case FieldType.SInt64: + case FieldType.SFixed32: + case FieldType.SFixed64: + case FieldType.Float: + case FieldType.Double: + case FieldType.UInt32: + case FieldType.UInt64: + case FieldType.Fixed32: + case FieldType.Fixed64: + // The simple Object.ToString converts using the current culture. + // We want to always use the invariant culture so it's predictable. + generator.Print(((IConvertible) value).ToString(CultureInfo.InvariantCulture)); + break; + case FieldType.Bool: + // Explicitly use the Java true/false + generator.Print((bool) value ? "true" : "false"); + break; + + case FieldType.String: + generator.Print("\""); + generator.Print(EscapeText((string) value)); + generator.Print("\""); + break; + + case FieldType.Bytes: { + generator.Print("\""); + generator.Print(EscapeBytes((ByteString) value)); + generator.Print("\""); + break; + } + + case FieldType.Enum: { + generator.Print(((EnumValueDescriptor) value).Name); + break; + } + + case FieldType.Message: + case FieldType.Group: + Print((IMessage) value, generator); + break; + } + } + + private static void PrintUnknownFields(UnknownFieldSet unknownFields, TextGenerator generator) { + foreach (KeyValuePair<int, UnknownField> entry in unknownFields.FieldDictionary) { + String prefix = entry.Key.ToString() + ": "; + UnknownField field = entry.Value; + + foreach (ulong value in field.VarintList) { + generator.Print(prefix); + generator.Print(value.ToString()); + generator.Print("\n"); + } + foreach (uint value in field.Fixed32List) { + generator.Print(prefix); + generator.Print(string.Format("0x{0:x8}", value)); + generator.Print("\n"); + } + foreach (ulong value in field.Fixed64List) { + generator.Print(prefix); + generator.Print(string.Format("0x{0:x16}", value)); + generator.Print("\n"); + } + foreach (ByteString value in field.LengthDelimitedList) { + generator.Print(entry.Key.ToString()); + generator.Print(": \""); + generator.Print(EscapeBytes(value)); + generator.Print("\"\n"); + } + foreach (UnknownFieldSet value in field.GroupList) { + generator.Print(entry.Key.ToString()); + generator.Print(" {\n"); + generator.Indent(); + PrintUnknownFields(value, generator); + generator.Outdent(); + generator.Print("}\n"); + } + } + } + + internal static ulong ParseUInt64(string text) { + return (ulong) ParseInteger(text, false, true); + } + + internal static long ParseInt64(string text) { + return ParseInteger(text, true, true); + } + + internal static uint ParseUInt32(string text) { + return (uint) ParseInteger(text, false, false); + } + + internal static int ParseInt32(string text) { + return (int) ParseInteger(text, true, false); + } + + /// <summary> + /// Parses an integer in hex (leading 0x), decimal (no prefix) or octal (leading 0). + /// Only a negative sign is permitted, and it must come before the radix indicator. + /// </summary> + private static long ParseInteger(string text, bool isSigned, bool isLong) { + string original = text; + bool negative = false; + if (text.StartsWith("-")) { + if (!isSigned) { + throw new FormatException("Number must be positive: " + original); + } + negative = true; + text = text.Substring(1); + } + + int radix = 10; + if (text.StartsWith("0x")) { + radix = 16; + text = text.Substring(2); + } else if (text.StartsWith("0")) { + radix = 8; + } + + ulong result; + try { + // Workaround for https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=278448 + // We should be able to use Convert.ToUInt64 for all cases. + result = radix == 10 ? ulong.Parse(text) : Convert.ToUInt64(text, radix); + } catch (OverflowException) { + // Convert OverflowException to FormatException so there's a single exception type this method can throw. + string numberDescription = string.Format("{0}-bit {1}signed integer", isLong ? 64 : 32, isSigned ? "" : "un"); + throw new FormatException("Number out of range for " + numberDescription + ": " + original); + } + + if (negative) { + ulong max = isLong ? 0x8000000000000000UL : 0x80000000L; + if (result > max) { + string numberDescription = string.Format("{0}-bit signed integer", isLong ? 64 : 32); + throw new FormatException("Number out of range for " + numberDescription + ": " + original); + } + return -((long) result); + } else { + ulong max = isSigned + ? (isLong ? (ulong) long.MaxValue : int.MaxValue) + : (isLong ? ulong.MaxValue : uint.MaxValue); + if (result > max) { + string numberDescription = string.Format("{0}-bit {1}signed integer", isLong ? 64 : 32, isSigned ? "" : "un"); + throw new FormatException("Number out of range for " + numberDescription + ": " + original); + } + return (long) result; + } + } + + /// <summary> + /// Tests a character to see if it's an octal digit. + /// </summary> + private static bool IsOctal(char c) { + return '0' <= c && c <= '7'; + } + + /// <summary> + /// Tests a character to see if it's a hex digit. + /// </summary> + private static bool IsHex(char c) { + return ('0' <= c && c <= '9') || + ('a' <= c && c <= 'f') || + ('A' <= c && c <= 'F'); + } + + /// <summary> + /// Interprets a character as a digit (in any base up to 36) and returns the + /// numeric value. + /// </summary> + private static int ParseDigit(char c) { + if ('0' <= c && c <= '9') { + return c - '0'; + } else if ('a' <= c && c <= 'z') { + return c - 'a' + 10; + } else { + return c - 'A' + 10; + } + } + + /// <summary> + /// Unescapes a text string as escaped using <see cref="EscapeText(string)" />. + /// Two-digit hex escapes (starting with "\x" are also recognised. + /// </summary> + internal static string UnescapeText(string input) { + return UnescapeBytes(input).ToStringUtf8(); + } + + /// <summary> + /// Like <see cref="EscapeBytes" /> but escapes a text string. + /// The string is first encoded as UTF-8, then each byte escaped individually. + /// The returned value is guaranteed to be entirely ASCII. + /// </summary> + internal static string EscapeText(string input) { + return EscapeBytes(ByteString.CopyFromUtf8(input)); + } + + /// <summary> + /// Escapes bytes in the format used in protocol buffer text format, which + /// is the same as the format used for C string literals. All bytes + /// that are not printable 7-bit ASCII characters are escaped, as well as + /// backslash, single-quote, and double-quote characters. Characters for + /// which no defined short-hand escape sequence is defined will be escaped + /// using 3-digit octal sequences. + /// The returned value is guaranteed to be entirely ASCII. + /// </summary> + internal static String EscapeBytes(ByteString input) { + StringBuilder builder = new StringBuilder(input.Length); + foreach (byte b in input) { + switch (b) { + // C# does not use \a or \v + case 0x07: builder.Append("\\a" ); break; + case (byte)'\b': builder.Append("\\b" ); break; + case (byte)'\f': builder.Append("\\f" ); break; + case (byte)'\n': builder.Append("\\n" ); break; + case (byte)'\r': builder.Append("\\r" ); break; + case (byte)'\t': builder.Append("\\t" ); break; + case 0x0b: builder.Append("\\v" ); break; + case (byte)'\\': builder.Append("\\\\"); break; + case (byte)'\'': builder.Append("\\\'"); break; + case (byte)'"' : builder.Append("\\\""); break; + default: + if (b >= 0x20 && b < 128) { + builder.Append((char) b); + } else { + builder.Append('\\'); + builder.Append((char) ('0' + ((b >> 6) & 3))); + builder.Append((char) ('0' + ((b >> 3) & 7))); + builder.Append((char) ('0' + (b & 7))); + } + break; + } + } + return builder.ToString(); + } + + /// <summary> + /// Performs string unescaping from C style (octal, hex, form feeds, tab etc) into a byte string. + /// </summary> + internal static ByteString UnescapeBytes(string input) { + byte[] result = new byte[input.Length]; + int pos = 0; + for (int i = 0; i < input.Length; i++) { + char c = input[i]; + if (c > 127 || c < 32) { + throw new FormatException("Escaped string must only contain ASCII"); + } + if (c != '\\') { + result[pos++] = (byte) c; + continue; + } + if (i + 1 >= input.Length) { + throw new FormatException("Invalid escape sequence: '\\' at end of string."); + } + + i++; + c = input[i]; + if (c >= '0' && c <= '7') { + // Octal escape. + int code = ParseDigit(c); + if (i + 1 < input.Length && IsOctal(input[i+1])) { + i++; + code = code * 8 + ParseDigit(input[i]); + } + if (i + 1 < input.Length && IsOctal(input[i+1])) { + i++; + code = code * 8 + ParseDigit(input[i]); + } + result[pos++] = (byte) code; + } else { + switch (c) { + case 'a': result[pos++] = 0x07; break; + case 'b': result[pos++] = (byte) '\b'; break; + case 'f': result[pos++] = (byte) '\f'; break; + case 'n': result[pos++] = (byte) '\n'; break; + case 'r': result[pos++] = (byte) '\r'; break; + case 't': result[pos++] = (byte) '\t'; break; + case 'v': result[pos++] = 0x0b; break; + case '\\': result[pos++] = (byte) '\\'; break; + case '\'': result[pos++] = (byte) '\''; break; + case '"': result[pos++] = (byte) '\"'; break; + + case 'x': + // hex escape + int code; + if (i + 1 < input.Length && IsHex(input[i+1])) { + i++; + code = ParseDigit(input[i]); + } else { + throw new FormatException("Invalid escape sequence: '\\x' with no digits"); + } + if (i + 1 < input.Length && IsHex(input[i+1])) { + ++i; + code = code * 16 + ParseDigit(input[i]); + } + result[pos++] = (byte)code; + break; + + default: + throw new FormatException("Invalid escape sequence: '\\" + c + "'"); + } + } + } + + return ByteString.CopyFrom(result, 0, pos); + } + + public static void Merge(string text, IBuilder builder) { + Merge(text, ExtensionRegistry.Empty, builder); + } + + public static void Merge(TextReader reader, IBuilder builder) { + Merge(reader, ExtensionRegistry.Empty, builder); + } + + public static void Merge(TextReader reader, ExtensionRegistry registry, IBuilder builder) { + Merge(reader.ReadToEnd(), registry, builder); + } + + public static void Merge(string text, ExtensionRegistry registry, IBuilder builder) { + TextTokenizer tokenizer = new TextTokenizer(text); + + while (!tokenizer.AtEnd) { + MergeField(tokenizer, registry, builder); + } + } + + /// <summary> + /// Parses a single field from the specified tokenizer and merges it into + /// the builder. + /// </summary> + private static void MergeField(TextTokenizer tokenizer, ExtensionRegistry extensionRegistry, + IBuilder builder) { + + FieldDescriptor field; + MessageDescriptor type = builder.DescriptorForType; + ExtensionInfo extension = null; + + if (tokenizer.TryConsume("[")) { + // An extension. + StringBuilder name = new StringBuilder(tokenizer.ConsumeIdentifier()); + while (tokenizer.TryConsume(".")) { + name.Append("."); + name.Append(tokenizer.ConsumeIdentifier()); + } + + extension = extensionRegistry[name.ToString()]; + + if (extension == null) { + throw tokenizer.CreateFormatExceptionPreviousToken("Extension \"" + name + "\" not found in the ExtensionRegistry."); + } else if (extension.Descriptor.ContainingType != type) { + throw tokenizer.CreateFormatExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + + type.FullName + "\"."); + } + + tokenizer.Consume("]"); + + field = extension.Descriptor; + } else { + String name = tokenizer.ConsumeIdentifier(); + field = type.FindDescriptor<FieldDescriptor>(name); + + // Group names are expected to be capitalized as they appear in the + // .proto file, which actually matches their type names, not their field + // names. + if (field == null) { + // Explicitly specify the invariant culture so that this code does not break when + // executing in Turkey. + String lowerName = name.ToLowerInvariant(); + field = type.FindDescriptor<FieldDescriptor>(lowerName); + // If the case-insensitive match worked but the field is NOT a group, + // TODO(jonskeet): What? Java comment ends here! + if (field != null && field.FieldType != FieldType.Group) { + field = null; + } + } + // Again, special-case group names as described above. + if (field != null && field.FieldType == FieldType.Group && field.MessageType.Name != name) { + field = null; + } + + if (field == null) { + throw tokenizer.CreateFormatExceptionPreviousToken( + "Message type \"" + type.FullName + "\" has no field named \"" + name + "\"."); + } + } + + object value = null; + + if (field.MappedType == MappedType.Message) { + tokenizer.TryConsume(":"); // optional + + String endToken; + if (tokenizer.TryConsume("<")) { + endToken = ">"; + } else { + tokenizer.Consume("{"); + endToken = "}"; + } + + IBuilder subBuilder; + if (extension == null) { + subBuilder = builder.CreateBuilderForField(field); + } else { + subBuilder = extension.DefaultInstance.WeakCreateBuilderForType(); + } + + while (!tokenizer.TryConsume(endToken)) { + if (tokenizer.AtEnd) { + throw tokenizer.CreateFormatException("Expected \"" + endToken + "\"."); + } + MergeField(tokenizer, extensionRegistry, subBuilder); + } + + value = subBuilder.WeakBuild(); + + } else { + tokenizer.Consume(":"); + + switch (field.FieldType) { + case FieldType.Int32: + case FieldType.SInt32: + case FieldType.SFixed32: + value = tokenizer.ConsumeInt32(); + break; + + case FieldType.Int64: + case FieldType.SInt64: + case FieldType.SFixed64: + value = tokenizer.ConsumeInt64(); + break; + + case FieldType.UInt32: + case FieldType.Fixed32: + value = tokenizer.ConsumeUInt32(); + break; + + case FieldType.UInt64: + case FieldType.Fixed64: + value = tokenizer.ConsumeUInt64(); + break; + + case FieldType.Float: + value = tokenizer.ConsumeFloat(); + break; + + case FieldType.Double: + value = tokenizer.ConsumeDouble(); + break; + + case FieldType.Bool: + value = tokenizer.ConsumeBoolean(); + break; + + case FieldType.String: + value = tokenizer.ConsumeString(); + break; + + case FieldType.Bytes: + value = tokenizer.ConsumeByteString(); + break; + + case FieldType.Enum: { + EnumDescriptor enumType = field.EnumType; + + if (tokenizer.LookingAtInteger()) { + int number = tokenizer.ConsumeInt32(); + value = enumType.FindValueByNumber(number); + if (value == null) { + throw tokenizer.CreateFormatExceptionPreviousToken( + "Enum type \"" + enumType.FullName + + "\" has no value with number " + number + "."); + } + } else { + String id = tokenizer.ConsumeIdentifier(); + value = enumType.FindValueByName(id); + if (value == null) { + throw tokenizer.CreateFormatExceptionPreviousToken( + "Enum type \"" + enumType.FullName + + "\" has no value named \"" + id + "\"."); + } + } + + break; + } + + case FieldType.Message: + case FieldType.Group: + throw new InvalidOperationException("Can't get here."); + } + } + + if (field.IsRepeated) { + builder.WeakAddRepeatedField(field, value); + } else { + builder.SetField(field, value); + } + } + } +} diff --git a/src/ProtocolBuffers/TextGenerator.cs b/src/ProtocolBuffers/TextGenerator.cs new file mode 100644 index 00000000..fb0f66dd --- /dev/null +++ b/src/ProtocolBuffers/TextGenerator.cs @@ -0,0 +1,115 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.IO; +using System.Text; + +namespace Google.ProtocolBuffers { + + /// <summary> + /// Helper class to control indentation. Used for TextFormat and by ProtoGen. + /// </summary> + public sealed class TextGenerator { + + /// <summary> + /// Writer to write formatted text to. + /// </summary> + private readonly TextWriter writer; + + /// <summary> + /// Keeps track of whether the next piece of text should be indented + /// </summary> + bool atStartOfLine = true; + + /// <summary> + /// Keeps track of the current level of indentation + /// </summary> + readonly StringBuilder indent = new StringBuilder(); + + /// <summary> + /// Creates a generator writing to the given writer. The writer + /// is not closed by this class. + /// </summary> + public TextGenerator(TextWriter writer) { + this.writer = writer; + } + + /// <summary> + /// Indents text by two spaces. After calling Indent(), two spaces + /// will be inserted at the beginning of each line of text. Indent() may + /// be called multiple times to produce deeper indents. + /// </summary> + public void Indent() { + indent.Append(" "); + } + + /// <summary> + /// Reduces the current indent level by two spaces. + /// </summary> + public void Outdent() { + if (indent.Length == 0) { + throw new InvalidOperationException("Too many calls to Outdent()"); + } + indent.Length -= 2; + } + + public void WriteLine(string text) { + Print(text); + Print("\n"); + } + + public void WriteLine(string format, params object[] args) { + WriteLine(string.Format(format, args)); + } + + public void WriteLine() { + WriteLine(""); + } + + /// <summary> + /// Prints the given text to the output stream, indenting at line boundaries. + /// </summary> + /// <param name="text"></param> + public void Print(string text) { + int pos = 0; + + for (int i = 0; i < text.Length; i++) { + if (text[i] == '\n') { + // TODO(jonskeet): Use Environment.NewLine? + Write(text.Substring(pos, i - pos + 1)); + pos = i + 1; + atStartOfLine = true; + } + } + Write(text.Substring(pos)); + } + + public void Write(string format, params object[] args) { + Write(string.Format(format, args)); + } + + private void Write(string data) { + if (data.Length == 0) { + return; + } + if (atStartOfLine) { + atStartOfLine = false; + writer.Write(indent); + } + writer.Write(data); + } + } +} diff --git a/src/ProtocolBuffers/TextTokenizer.cs b/src/ProtocolBuffers/TextTokenizer.cs new file mode 100644 index 00000000..d53ae596 --- /dev/null +++ b/src/ProtocolBuffers/TextTokenizer.cs @@ -0,0 +1,390 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Globalization; +using System.Text.RegularExpressions; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Represents a stream of tokens parsed from a string. + /// </summary> + internal sealed class TextTokenizer { + private readonly string text; + private string currentToken; + + /// <summary> + /// The character index within the text to perform the next regex match at. + /// </summary> + private int matchPos = 0; + + /// <summary> + /// The character index within the text at which the current token begins. + /// </summary> + private int pos = 0; + + /// <summary> + /// The line number of the current token. + /// </summary> + private int line = 0; + /// <summary> + /// The column number of the current token. + /// </summary> + private int column = 0; + + /// <summary> + /// The line number of the previous token. + /// </summary> + private int previousLine = 0; + /// <summary> + /// The column number of the previous token. + /// </summary> + private int previousColumn = 0; + + private static readonly Regex WhitespaceAndCommentPattern = new Regex("\\G(\\s|(#.*$))+", + RegexOptions.Compiled | RegexOptions.Multiline); + private static readonly Regex TokenPattern = new Regex( + "\\G[a-zA-Z_][0-9a-zA-Z_+-]*|" + // an identifier + "\\G[0-9+-][0-9a-zA-Z_.+-]*|" + // a number + "\\G\"([^\"\\\n\\\\]|\\\\.)*(\"|\\\\?$)|" + // a double-quoted string + "\\G\'([^\"\\\n\\\\]|\\\\.)*(\'|\\\\?$)", // a single-quoted string + RegexOptions.Compiled | RegexOptions.Multiline); + + private static readonly Regex DoubleInfinity = new Regex("^-?inf(inity)?$", RegexOptions.Compiled | RegexOptions.IgnoreCase); + private static readonly Regex FloatInfinity = new Regex("^-?inf(inity)?f?$", RegexOptions.Compiled | RegexOptions.IgnoreCase); + private static readonly Regex FloatNan = new Regex("^nanf?$", RegexOptions.Compiled | RegexOptions.IgnoreCase); + + /** Construct a tokenizer that parses tokens from the given text. */ + public TextTokenizer(string text) { + this.text = text; + SkipWhitespace(); + NextToken(); + } + + /// <summary> + /// Are we at the end of the input? + /// </summary> + public bool AtEnd { + get { return currentToken.Length == 0; } + } + + /// <summary> + /// Advances to the next token. + /// </summary> + public void NextToken() { + previousLine = line; + previousColumn = column; + + // Advance the line counter to the current position. + while (pos < matchPos) { + if (text[pos] == '\n') { + ++line; + column = 0; + } else { + ++column; + } + ++pos; + } + + // Match the next token. + if (matchPos == text.Length) { + // EOF + currentToken = ""; + } else { + Match match = TokenPattern.Match(text, matchPos); + if (match.Success) { + currentToken = match.Value; + matchPos += match.Length; + } else { + // Take one character. + currentToken = text[matchPos].ToString(); + matchPos++; + } + + SkipWhitespace(); + } + } + + /// <summary> + /// Skip over any whitespace so that matchPos starts at the next token. + /// </summary> + private void SkipWhitespace() { + Match match = WhitespaceAndCommentPattern.Match(text, matchPos); + if (match.Success) { + matchPos += match.Length; + } + } + + /// <summary> + /// If the next token exactly matches the given token, consume it and return + /// true. Otherwise, return false without doing anything. + /// </summary> + public bool TryConsume(string token) { + if (currentToken == token) { + NextToken(); + return true; + } + return false; + } + + /* + * If the next token exactly matches {@code token}, consume it. Otherwise, + * throw a {@link ParseException}. + */ + /// <summary> + /// If the next token exactly matches the specified one, consume it. + /// Otherwise, throw a FormatException. + /// </summary> + /// <param name="token"></param> + public void Consume(string token) { + if (!TryConsume(token)) { + throw CreateFormatException("Expected \"" + token + "\"."); + } + } + + /// <summary> + /// Returns true if the next token is an integer, but does not consume it. + /// </summary> + public bool LookingAtInteger() { + if (currentToken.Length == 0) { + return false; + } + + char c = currentToken[0]; + return ('0' <= c && c <= '9') || c == '-' || c == '+'; + } + + /// <summary> + /// If the next token is an identifier, consume it and return its value. + /// Otherwise, throw a FormatException. + /// </summary> + public string ConsumeIdentifier() { + foreach (char c in currentToken) { + if (('a' <= c && c <= 'z') || + ('A' <= c && c <= 'Z') || + ('0' <= c && c <= '9') || + (c == '_') || (c == '.')) { + // OK + } else { + throw CreateFormatException("Expected identifier."); + } + } + + string result = currentToken; + NextToken(); + return result; + } + + /// <summary> + /// If the next token is a 32-bit signed integer, consume it and return its + /// value. Otherwise, throw a FormatException. + /// </summary> + public int ConsumeInt32() { + try { + int result = TextFormat.ParseInt32(currentToken); + NextToken(); + return result; + } catch (FormatException e) { + throw CreateIntegerParseException(e); + } + } + + /// <summary> + /// If the next token is a 32-bit unsigned integer, consume it and return its + /// value. Otherwise, throw a FormatException. + /// </summary> + public uint ConsumeUInt32() { + try { + uint result = TextFormat.ParseUInt32(currentToken); + NextToken(); + return result; + } catch (FormatException e) { + throw CreateIntegerParseException(e); + } + } + + /// <summary> + /// If the next token is a 64-bit signed integer, consume it and return its + /// value. Otherwise, throw a FormatException. + /// </summary> + public long ConsumeInt64() { + try { + long result = TextFormat.ParseInt64(currentToken); + NextToken(); + return result; + } catch (FormatException e) { + throw CreateIntegerParseException(e); + } + } + + /// <summary> + /// If the next token is a 64-bit unsigned integer, consume it and return its + /// value. Otherwise, throw a FormatException. + /// </summary> + public ulong ConsumeUInt64() { + try { + ulong result = TextFormat.ParseUInt64(currentToken); + NextToken(); + return result; + } catch (FormatException e) { + throw CreateIntegerParseException(e); + } + } + + /// <summary> + /// If the next token is a double, consume it and return its value. + /// Otherwise, throw a FormatException. + /// </summary> + public double ConsumeDouble() { + // We need to parse infinity and nan separately because + // double.Parse() does not accept "inf", "infinity", or "nan". + if (DoubleInfinity.IsMatch(currentToken)) { + bool negative = currentToken.StartsWith("-"); + NextToken(); + return negative ? double.NegativeInfinity : double.PositiveInfinity; + } + if (currentToken.Equals("nan", StringComparison.InvariantCultureIgnoreCase)) { + NextToken(); + return Double.NaN; + } + + try { + double result = double.Parse(currentToken, CultureInfo.InvariantCulture); + NextToken(); + return result; + } catch (FormatException e) { + throw CreateFloatParseException(e); + } catch (OverflowException e) { + throw CreateFloatParseException(e); + } + } + + /// <summary> + /// If the next token is a float, consume it and return its value. + /// Otherwise, throw a FormatException. + /// </summary> + public float ConsumeFloat() { + + // We need to parse infinity and nan separately because + // Float.parseFloat() does not accept "inf", "infinity", or "nan". + if (FloatInfinity.IsMatch(currentToken)) { + bool negative = currentToken.StartsWith("-"); + NextToken(); + return negative ? float.NegativeInfinity : float.PositiveInfinity; + } + if (FloatNan.IsMatch(currentToken)) { + NextToken(); + return float.NaN; + } + + if (currentToken.EndsWith("f")) { + currentToken = currentToken.TrimEnd('f'); + } + + try { + float result = float.Parse(currentToken, CultureInfo.InvariantCulture); + NextToken(); + return result; + } catch (FormatException e) { + throw CreateFloatParseException(e); + } catch (OverflowException e) { + throw CreateFloatParseException(e); + } + } + + /// <summary> + /// If the next token is a Boolean, consume it and return its value. + /// Otherwise, throw a FormatException. + /// </summary> + public bool ConsumeBoolean() { + if (currentToken == "true") { + NextToken(); + return true; + } + if (currentToken == "false") { + NextToken(); + return false; + } + throw CreateFormatException("Expected \"true\" or \"false\"."); + } + + /// <summary> + /// If the next token is a string, consume it and return its (unescaped) value. + /// Otherwise, throw a FormatException. + /// </summary> + public string ConsumeString() { + return ConsumeByteString().ToStringUtf8(); + } + + /// <summary> + /// If the next token is a string, consume it, unescape it as a + /// ByteString and return it. Otherwise, throw a FormatException. + /// </summary> + public ByteString ConsumeByteString() { + char quote = currentToken.Length > 0 ? currentToken[0] : '\0'; + if (quote != '\"' && quote != '\'') { + throw CreateFormatException("Expected string."); + } + + if (currentToken.Length < 2 || + currentToken[currentToken.Length-1] != quote) { + throw CreateFormatException("String missing ending quote."); + } + + try { + string escaped = currentToken.Substring(1, currentToken.Length - 2); + ByteString result = TextFormat.UnescapeBytes(escaped); + NextToken(); + return result; + } catch (FormatException e) { + throw CreateFormatException(e.Message); + } + } + + /// <summary> + /// Returns a format exception with the current line and column numbers + /// in the description, suitable for throwing. + /// </summary> + public FormatException CreateFormatException(string description) { + // Note: People generally prefer one-based line and column numbers. + return new FormatException((line + 1) + ":" + (column + 1) + ": " + description); + } + + /// <summary> + /// Returns a format exception with the line and column numbers of the + /// previous token in the description, suitable for throwing. + /// </summary> + public FormatException CreateFormatExceptionPreviousToken(string description) { + // Note: People generally prefer one-based line and column numbers. + return new FormatException((previousLine + 1) + ":" + (previousColumn + 1) + ": " + description); + } + + /// <summary> + /// Constructs an appropriate FormatException for the given existing exception + /// when trying to parse an integer. + /// </summary> + private FormatException CreateIntegerParseException(FormatException e) { + return CreateFormatException("Couldn't parse integer: " + e.Message); + } + + /// <summary> + /// Constructs an appropriate FormatException for the given existing exception + /// when trying to parse a float or double. + /// </summary> + private FormatException CreateFloatParseException(Exception e) { + return CreateFormatException("Couldn't parse number: " + e.Message); + } + } +} diff --git a/src/ProtocolBuffers/UninitializedMessageException.cs b/src/ProtocolBuffers/UninitializedMessageException.cs new file mode 100644 index 00000000..b0d601bd --- /dev/null +++ b/src/ProtocolBuffers/UninitializedMessageException.cs @@ -0,0 +1,127 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections; +using System.Collections.Generic; +using System.Text; +using Google.ProtocolBuffers.Collections; +using Google.ProtocolBuffers.Descriptors; + +namespace Google.ProtocolBuffers { + /// <summary> + /// TODO(jonskeet): Write summary text. + /// </summary> + public sealed class UninitializedMessageException : Exception { + + private readonly IList<string> missingFields; + + public UninitializedMessageException(IMessage message) + : this(FindMissingFields(message)) { + } + + private UninitializedMessageException(IList<string> missingFields) + : base(BuildDescription(missingFields)) { + this.missingFields = Lists.AsReadOnly(missingFields); + } + + + /// <summary> + /// Converts this exception into an InvalidProtocolBufferException. + /// When a parsed message is missing required fields, this should be thrown + /// instead of UninitializedMessageException. + /// </summary> + public InvalidProtocolBufferException AsInvalidProtocolBufferException() { + return new InvalidProtocolBufferException(Message); + } + + /// <summary> + /// Constructs the description string for a given list of missing fields. + /// </summary> + private static string BuildDescription(IEnumerable<string> missingFields) { + StringBuilder description = new StringBuilder("Message missing required fields: "); + bool first = true; + foreach(string field in missingFields) { + if (first) { + first = false; + } else { + description.Append(", "); + } + description.Append(field); + } + return description.ToString(); + } + + /// <summary> + /// Returns a list of the full "paths" of missing required + /// fields in the specified message. + /// </summary> + private static IList<String> FindMissingFields(IMessage message) { + List<String> results = new List<String>(); + FindMissingFields(message, "", results); + return results; + } + + /// <summary> + /// Recursive helper implementing FindMissingFields. + /// </summary> + private static void FindMissingFields(IMessage message, String prefix, List<String> results) { + foreach (FieldDescriptor field in message.DescriptorForType.Fields) { + if (field.IsRequired && !message.HasField(field)) { + results.Add(prefix + field.Name); + } + } + + foreach (KeyValuePair<FieldDescriptor, object> entry in message.AllFields) { + FieldDescriptor field = entry.Key; + object value = entry.Value; + + if (field.MappedType == MappedType.Message) { + if (field.IsRepeated) { + int i = 0; + foreach (object element in (IEnumerable) value) { + FindMissingFields((IMessage) element, SubMessagePrefix(prefix, field, i++), results); + } + } else { + if (message.HasField(field)) { + FindMissingFields((IMessage) value, SubMessagePrefix(prefix, field, -1), results); + } + } + } + } + } + + private static String SubMessagePrefix(String prefix, FieldDescriptor field, int index) { + StringBuilder result = new StringBuilder(prefix); + if (field.IsExtension) { + result.Append('(') + .Append(field.FullName) + .Append(')'); + } else { + result.Append(field.Name); + } + if (index != -1) { + result.Append('[') + .Append(index) + .Append(']'); + } + result.Append('.'); + return result.ToString(); + } + } +} + + + diff --git a/src/ProtocolBuffers/UnknownField.cs b/src/ProtocolBuffers/UnknownField.cs new file mode 100644 index 00000000..76afe680 --- /dev/null +++ b/src/ProtocolBuffers/UnknownField.cs @@ -0,0 +1,321 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System.Collections.Generic; +using System.Collections.ObjectModel; +using Google.ProtocolBuffers.Collections; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Represents a single field in an UnknownFieldSet. + /// + /// An UnknownField consists of five lists of values. The lists correspond + /// to the five "wire types" used in the protocol buffer binary format. + /// The wire type of each field can be determined from the encoded form alone, + /// without knowing the field's declared type. So, we are able to parse + /// unknown values at least this far and separate them. Normally, only one + /// of the five lists will contain any values, since it is impossible to + /// define a valid message type that declares two different types for the + /// same field number. However, the code is designed to allow for the case + /// where the same unknown field number is encountered using multiple different + /// wire types. + /// + /// UnknownField is an immutable class. To construct one, you must use an + /// UnknownField.Builder. + /// </summary> + public sealed class UnknownField { + + private static readonly UnknownField defaultInstance = CreateBuilder().Build(); + private readonly ReadOnlyCollection<ulong> varintList; + private readonly ReadOnlyCollection<uint> fixed32List; + private readonly ReadOnlyCollection<ulong> fixed64List; + private readonly ReadOnlyCollection<ByteString> lengthDelimitedList; + private readonly ReadOnlyCollection<UnknownFieldSet> groupList; + + private UnknownField(ReadOnlyCollection<ulong> varintList, + ReadOnlyCollection<uint> fixed32List, + ReadOnlyCollection<ulong> fixed64List, + ReadOnlyCollection<ByteString> lengthDelimitedList, + ReadOnlyCollection<UnknownFieldSet> groupList) { + this.varintList = varintList; + this.fixed32List = fixed32List; + this.fixed64List = fixed64List; + this.lengthDelimitedList = lengthDelimitedList; + this.groupList = groupList; + } + + public static UnknownField DefaultInstance { + get { return defaultInstance; } + } + + /// <summary> + /// The list of varint values for this field. + /// </summary> + public IList<ulong> VarintList { + get { return varintList; } + } + + /// <summary> + /// The list of fixed32 values for this field. + /// </summary> + public IList<uint> Fixed32List { + get { return fixed32List; } + } + + /// <summary> + /// The list of fixed64 values for this field. + /// </summary> + public IList<ulong> Fixed64List { + get { return fixed64List; } + } + + /// <summary> + /// The list of length-delimited values for this field. + /// </summary> + public IList<ByteString> LengthDelimitedList { + get { return lengthDelimitedList; } + } + + /// <summary> + /// The list of embedded group values for this field. These + /// are represented using UnknownFieldSets rather than Messages + /// since the group's type is presumably unknown. + /// </summary> + public IList<UnknownFieldSet> GroupList { + get { return groupList; } + } + + /// <summary> + /// Constructs a new Builder. + /// </summary> + public static Builder CreateBuilder() { + return new Builder(); + } + + /// <summary> + /// Constructs a new Builder and initializes it to a copy of <paramref name="copyFrom"/>. + /// </summary> + public static Builder CreateBuilder(UnknownField copyFrom) { + return new Builder().MergeFrom(copyFrom); + } + + /// <summary> + /// Serializes the field, including the field number, and writes it to + /// <paramref name="output"/>. + /// </summary> + public void WriteTo(int fieldNumber, CodedOutputStream output) { + foreach (ulong value in varintList) { + output.WriteUInt64(fieldNumber, value); + } + foreach (uint value in fixed32List) { + output.WriteFixed32(fieldNumber, value); + } + foreach (ulong value in fixed64List) { + output.WriteFixed64(fieldNumber, value); + } + foreach (ByteString value in lengthDelimitedList) { + output.WriteBytes(fieldNumber, value); + } + foreach (UnknownFieldSet value in groupList) { + output.WriteUnknownGroup(fieldNumber, value); + } + } + + /// <summary> + /// Computes the number of bytes required to encode this field, including field + /// number. + /// </summary> + public int GetSerializedSize(int fieldNumber) { + int result = 0; + foreach (ulong value in varintList) { + result += CodedOutputStream.ComputeUInt64Size(fieldNumber, value); + } + foreach (uint value in fixed32List) { + result += CodedOutputStream.ComputeFixed32Size(fieldNumber, value); + } + foreach (ulong value in fixed64List) { + result += CodedOutputStream.ComputeFixed64Size(fieldNumber, value); + } + foreach (ByteString value in lengthDelimitedList) { + result += CodedOutputStream.ComputeBytesSize(fieldNumber, value); + } + foreach (UnknownFieldSet value in groupList) { + result += CodedOutputStream.ComputeUnknownGroupSize(fieldNumber, value); + } + return result; + } + + /// <summary> + /// Serializes the length-delimited values of the field, including field + /// number, and writes them to <paramref name="output"/> using the MessageSet wire format. + /// </summary> + /// <param name="fieldNumber"></param> + /// <param name="output"></param> + public void WriteAsMessageSetExtensionTo(int fieldNumber, CodedOutputStream output) { + foreach (ByteString value in lengthDelimitedList) { + output.WriteRawMessageSetExtension(fieldNumber, value); + } + } + + /// <summary> + /// Get the number of bytes required to encode this field, incuding field number, + /// using the MessageSet wire format. + /// </summary> + public int GetSerializedSizeAsMessageSetExtension(int fieldNumber) { + int result = 0; + foreach (ByteString value in lengthDelimitedList) { + result += CodedOutputStream.ComputeRawMessageSetExtensionSize(fieldNumber, value); + } + return result; + } + + /// <summary> + /// Used to build instances of UnknownField. + /// </summary> + public sealed class Builder { + + private List<ulong> varintList; + private List<uint> fixed32List; + private List<ulong> fixed64List; + private List<ByteString> lengthDelimitedList; + private List<UnknownFieldSet> groupList; + + /// <summary> + /// Builds the field. After building, the builder is reset to an empty + /// state. (This is actually easier than making it unusable.) + /// </summary> + public UnknownField Build() { + return new UnknownField(MakeReadOnly(ref varintList), + MakeReadOnly(ref fixed32List), + MakeReadOnly(ref fixed64List), + MakeReadOnly(ref lengthDelimitedList), + MakeReadOnly(ref groupList)); + } + + /// <summary> + /// Merge the values in <paramref name="other" /> into this field. For each list + /// of values, <paramref name="other"/>'s values are append to the ones in this + /// field. + /// </summary> + public Builder MergeFrom(UnknownField other) { + varintList = AddAll(varintList, other.VarintList); + fixed32List = AddAll(fixed32List, other.Fixed32List); + fixed64List = AddAll(fixed64List, other.Fixed64List); + lengthDelimitedList = AddAll(lengthDelimitedList, other.LengthDelimitedList); + groupList = AddAll(groupList, other.GroupList); + return this; + } + + /// <summary> + /// Returns a new list containing all of the given specified values from + /// both the <paramref name="current"/> and <paramref name="extras"/> lists. + /// If <paramref name="current" /> is null and <paramref name="extras"/> is empty, + /// null is returned. Otherwise, either a new list is created (if <paramref name="current" /> + /// is null) or the elements of <paramref name="extras"/> are added to <paramref name="current" />. + /// </summary> + private static List<T> AddAll<T>(List<T> current, IList<T> extras) + { + if (extras.Count == 0) { + return current; + } + if (current == null) { + current = new List<T>(extras); + } else { + current.AddRange(extras); + } + return current; + } + + /// <summary> + /// Clears the contents of this builder. + /// </summary> + public Builder Clear() { + varintList = null; + fixed32List = null; + fixed64List = null; + lengthDelimitedList = null; + groupList = null; + return this; + } + + /// <summary> + /// Adds a varint value. + /// </summary> + public Builder AddVarint(ulong value) { + varintList = Add(varintList, value); + return this; + } + + /// <summary> + /// Adds a fixed32 value. + /// </summary> + public Builder AddFixed32(uint value) { + fixed32List = Add(fixed32List, value); + return this; + } + + /// <summary> + /// Adds a fixed64 value. + /// </summary> + public Builder AddFixed64(ulong value) { + fixed64List = Add(fixed64List, value); + return this; + } + + /// <summary> + /// Adds a length-delimited value. + /// </summary> + public Builder AddLengthDelimited(ByteString value) { + lengthDelimitedList = Add(lengthDelimitedList, value); + return this; + } + + /// <summary> + /// Adds an embedded group. + /// </summary> + /// <param name="value"></param> + /// <returns></returns> + public Builder AddGroup(UnknownFieldSet value) { + groupList = Add(groupList, value); + return this; + } + + /// <summary> + /// Adds <paramref name="value"/> to the <paramref name="list"/>, creating + /// a new list if <paramref name="list"/> is null. The list is returned - either + /// the original reference or the new list. + /// </summary> + private static List<T> Add<T>(List<T> list, T value) { + if (list == null) { + list = new List<T>(); + } + list.Add(value); + return list; + } + + /// <summary> + /// Returns a read-only version of the given IList, and clears + /// the field used for <paramref name="list"/>. If the value + /// is null, an empty list is produced using Lists.Empty. + /// </summary> + /// <returns></returns> + private static ReadOnlyCollection<T> MakeReadOnly<T>(ref List<T> list) { + ReadOnlyCollection<T> ret = list == null ? Lists<T>.Empty : new ReadOnlyCollection<T>(list); + list = null; + return ret; + } + } + } +} diff --git a/src/ProtocolBuffers/UnknownFieldSet.cs b/src/ProtocolBuffers/UnknownFieldSet.cs new file mode 100644 index 00000000..18eacbe8 --- /dev/null +++ b/src/ProtocolBuffers/UnknownFieldSet.cs @@ -0,0 +1,626 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Collections.Generic; +using System.IO; +using Google.ProtocolBuffers.Collections; +using Google.ProtocolBuffers.Descriptors; +using Google.ProtocolBuffers.DescriptorProtos; + +namespace Google.ProtocolBuffers { + /// <summary> + /// Used to keep track of fields which were seen when parsing a protocol message + /// but whose field numbers or types are unrecognized. This most frequently + /// occurs when new fields are added to a message type and then messages containing + /// those fields are read by old software that was built before the new types were + /// added. + /// + /// Every message contains an UnknownFieldSet. + /// + /// Most users will never need to use this class directly. + /// </summary> + public sealed class UnknownFieldSet { + + private static readonly UnknownFieldSet defaultInstance = new UnknownFieldSet(new Dictionary<int, UnknownField>()); + + private readonly IDictionary<int, UnknownField> fields; + + private UnknownFieldSet(IDictionary<int, UnknownField> fields) { + this.fields = fields; + } + + /// <summary> + /// Creates a new unknown field set builder. + /// </summary> + public static Builder CreateBuilder() { + return new Builder(); + } + + /// <summary> + /// Creates a new unknown field set builder + /// and initialize it from <paramref name="original"/>. + /// </summary> + public static Builder CreateBuilder(UnknownFieldSet original) { + return new Builder().MergeFrom(original); + } + + public static UnknownFieldSet DefaultInstance { + get { return defaultInstance; } + } + + /// <summary> + /// Returns a read-only view of the mapping from field numbers to values. + /// </summary> + public IDictionary<int, UnknownField> FieldDictionary { + get { return Dictionaries.AsReadOnly(fields); } + } + + /// <summary> + /// Checks whether or not the given field number is present in the set. + /// </summary> + public bool HasField(int field) { + return fields.ContainsKey(field); + } + + /// <summary> + /// Fetches a field by number, returning an empty field if not present. + /// Never returns null. + /// </summary> + public UnknownField this[int number] { + get { + UnknownField ret; + if (!fields.TryGetValue(number, out ret)) { + ret = UnknownField.DefaultInstance; + } + return ret; + } + } + + /// <summary> + /// Serializes the set and writes it to <paramref name="output"/>. + /// </summary> + public void WriteTo(CodedOutputStream output) { + foreach (KeyValuePair<int, UnknownField> entry in fields) { + entry.Value.WriteTo(entry.Key, output); + } + } + + /// <summary> + /// Gets the number of bytes required to encode this set. + /// </summary> + public int SerializedSize { + get { + int result = 0; + foreach (KeyValuePair<int, UnknownField> entry in fields) { + result += entry.Value.GetSerializedSize(entry.Key); + } + return result; + } + } + + /// <summary> + /// Converts the set to a string in protocol buffer text format. This + /// is just a trivial wrapper around TextFormat.PrintToString. + /// </summary> + public override String ToString() { + return TextFormat.PrintToString(this); + } + + /// <summary> + /// Serializes the message to a ByteString and returns it. This is + /// just a trivial wrapper around WriteTo(CodedOutputStream). + /// </summary> + /// <returns></returns> + public ByteString ToByteString() { + ByteString.CodedBuilder codedBuilder = new ByteString.CodedBuilder(SerializedSize); + WriteTo(codedBuilder.CodedOutput); + return codedBuilder.Build(); + } + + /// <summary> + /// Serializes the message to a byte array and returns it. This is + /// just a trivial wrapper around WriteTo(CodedOutputStream). + /// </summary> + /// <returns></returns> + public byte[] ToByteArray() { + byte[] data = new byte[SerializedSize]; + CodedOutputStream output = CodedOutputStream.CreateInstance(data); + WriteTo(output); + output.CheckNoSpaceLeft(); + return data; + } + + /// <summary> + /// Serializes the message and writes it to <paramref name="output"/>. This is + /// just a trivial wrapper around WriteTo(CodedOutputStream). + /// </summary> + /// <param name="output"></param> + public void WriteTo(Stream output) { + CodedOutputStream codedOutput = CodedOutputStream.CreateInstance(output); + WriteTo(codedOutput); + codedOutput.Flush(); + } + + /// <summary> + /// Serializes the set and writes it to <paramref name="output"/> using + /// the MessageSet wire format. + /// </summary> + public void WriteAsMessageSetTo(CodedOutputStream output) { + foreach (KeyValuePair<int, UnknownField> entry in fields) { + entry.Value.WriteAsMessageSetExtensionTo(entry.Key, output); + } + } + + /// <summary> + /// Gets the number of bytes required to encode this set using the MessageSet + /// wire format. + /// </summary> + public int SerializedSizeAsMessageSet { + get { + int result = 0; + foreach (KeyValuePair<int, UnknownField> entry in fields) { + result += entry.Value.GetSerializedSizeAsMessageSetExtension(entry.Key); + } + return result; + } + } + + /// <summary> + /// Parses an UnknownFieldSet from the given input. + /// </summary> + public static UnknownFieldSet ParseFrom(CodedInputStream input) { + return CreateBuilder().MergeFrom(input).Build(); + } + + /// <summary> + /// Parses an UnknownFieldSet from the given data. + /// </summary> + public static UnknownFieldSet ParseFrom(ByteString data) { + return CreateBuilder().MergeFrom(data).Build(); + } + + /// <summary> + /// Parses an UnknownFieldSet from the given data. + /// </summary> + public static UnknownFieldSet ParseFrom(byte[] data) { + return CreateBuilder().MergeFrom(data).Build(); + } + + /// <summary> + /// Parses an UnknownFieldSet from the given input. + /// </summary> + public static UnknownFieldSet ParseFrom(Stream input) { + return CreateBuilder().MergeFrom(input).Build(); + } + + /// <summary> + /// Builder for UnknownFieldSets. + /// </summary> + public sealed class Builder + { + /// <summary> + /// Mapping from number to field. Note that by using a SortedList we ensure + /// that the fields will be serialized in ascending order. + /// </summary> + private IDictionary<int, UnknownField> fields = new SortedList<int, UnknownField>(); + + // Optimization: We keep around a builder for the last field that was + // modified so that we can efficiently add to it multiple times in a + // row (important when parsing an unknown repeated field). + int lastFieldNumber; + UnknownField.Builder lastField; + + internal Builder() { + } + + /// <summary> + /// Returns a field builder for the specified field number, including any values + /// which already exist. + /// </summary> + private UnknownField.Builder GetFieldBuilder(int number) { + if (lastField != null) { + if (number == lastFieldNumber) { + return lastField; + } + // Note: AddField() will reset lastField and lastFieldNumber. + AddField(lastFieldNumber, lastField.Build()); + } + if (number == 0) { + return null; + } + + lastField = UnknownField.CreateBuilder(); + UnknownField existing; + if (fields.TryGetValue(number, out existing)) { + lastField.MergeFrom(existing); + } + lastFieldNumber = number; + return lastField; + } + + /// <summary> + /// Build the UnknownFieldSet and return it. Once this method has been called, + /// this instance will no longer be usable. Calling any method after this + /// will throw a NullReferenceException. + /// </summary> + public UnknownFieldSet Build() { + GetFieldBuilder(0); // Force lastField to be built. + UnknownFieldSet result = fields.Count == 0 ? DefaultInstance : new UnknownFieldSet(fields); + fields = null; + return result; + } + + /// <summary> + /// Adds a field to the set. If a field with the same number already exists, it + /// is replaced. + /// </summary> + public Builder AddField(int number, UnknownField field) { + if (number == 0) { + throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number."); + } + if (lastField != null && lastFieldNumber == number) { + // Discard this. + lastField = null; + lastFieldNumber = 0; + } + fields[number] = field; + return this; + } + + /// <summary> + /// Resets the builder to an empty set. + /// </summary> + public Builder Clear() { + fields.Clear(); + lastFieldNumber = 0; + lastField = null; + return this; + } + + /// <summary> + /// Parse an entire message from <paramref name="input"/> and merge + /// its fields into this set. + /// </summary> + public Builder MergeFrom(CodedInputStream input) { + while (true) { + uint tag = input.ReadTag(); + if (tag == 0 || !MergeFieldFrom(tag, input)) { + break; + } + } + return this; + } + + /// <summary> + /// Parse a single field from <paramref name="input"/> and merge it + /// into this set. + /// </summary> + /// <param name="tag">The field's tag number, which was already parsed.</param> + /// <param name="input">The coded input stream containing the field</param> + /// <returns>false if the tag is an "end group" tag, true otherwise</returns> + public bool MergeFieldFrom(uint tag, CodedInputStream input) { + int number = WireFormat.GetTagFieldNumber(tag); + switch (WireFormat.GetTagWireType(tag)) { + case WireFormat.WireType.Varint: + GetFieldBuilder(number).AddVarint(input.ReadUInt64()); + return true; + case WireFormat.WireType.Fixed64: + GetFieldBuilder(number).AddFixed64(input.ReadFixed64()); + return true; + case WireFormat.WireType.LengthDelimited: + GetFieldBuilder(number).AddLengthDelimited(input.ReadBytes()); + return true; + case WireFormat.WireType.StartGroup: { + Builder subBuilder = CreateBuilder(); + input.ReadUnknownGroup(number, subBuilder); + GetFieldBuilder(number).AddGroup(subBuilder.Build()); + return true; + } + case WireFormat.WireType.EndGroup: + return false; + case WireFormat.WireType.Fixed32: + GetFieldBuilder(number).AddFixed32(input.ReadFixed32()); + return true; + default: + throw InvalidProtocolBufferException.InvalidWireType(); + } + } + + /// <summary> + /// Parses <paramref name="input"/> as an UnknownFieldSet and merge it + /// with the set being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream). + /// </summary> + public Builder MergeFrom(Stream input) { + CodedInputStream codedInput = CodedInputStream.CreateInstance(input); + MergeFrom(codedInput); + codedInput.CheckLastTagWas(0); + return this; + } + + /// <summary> + /// Parses <paramref name="data"/> as an UnknownFieldSet and merge it + /// with the set being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream). + /// </summary> + public Builder MergeFrom(ByteString data) { + CodedInputStream input = data.CreateCodedInput(); + MergeFrom(input); + input.CheckLastTagWas(0); + return this; + } + + /// <summary> + /// Parses <paramref name="data"/> as an UnknownFieldSet and merge it + /// with the set being built. This is just a small wrapper around + /// MergeFrom(CodedInputStream). + /// </summary> + public Builder MergeFrom(byte[] data) { + CodedInputStream input = CodedInputStream.CreateInstance(data); + MergeFrom(input); + input.CheckLastTagWas(0); + return this; + } + + /// <summary> + /// Convenience method for merging a new field containing a single varint + /// value. This is used in particular when an unknown enum value is + /// encountered. + /// </summary> + public Builder MergeVarintField(int number, ulong value) { + if (number == 0) { + throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number."); + } + GetFieldBuilder(number).AddVarint(value); + return this; + } + + /// <summary> + /// Merges the fields from <paramref name="other"/> into this set. + /// If a field number exists in both sets, the values in <paramref name="other"/> + /// will be appended to the values in this set. + /// </summary> + public Builder MergeFrom(UnknownFieldSet other) { + if (other != DefaultInstance) { + foreach(KeyValuePair<int, UnknownField> entry in other.fields) { + MergeField(entry.Key, entry.Value); + } + } + return this; + } + + /// <summary> + /// Checks if the given field number is present in the set. + /// </summary> + public bool HasField(int number) { + if (number == 0) { + throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number."); + } + return number == lastFieldNumber || fields.ContainsKey(number); + } + + /// <summary> + /// Adds a field to the unknown field set. If a field with the same + /// number already exists, the two are merged. + /// </summary> + public Builder MergeField(int number, UnknownField field) { + if (number == 0) { + throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number."); + } + if (HasField(number)) { + GetFieldBuilder(number).MergeFrom(field); + } else { + // Optimization: We could call getFieldBuilder(number).mergeFrom(field) + // in this case, but that would create a copy of the Field object. + // We'd rather reuse the one passed to us, so call AddField() instead. + AddField(number, field); + } + return this; + } + + internal void MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry, IBuilder builder) { + while (true) { + uint tag = input.ReadTag(); + if (tag == 0) { + break; + } + if (!MergeFieldFrom(input, extensionRegistry, builder, tag)) { + // end group tag + break; + } + } + } + + /// <summary> + /// Like <see cref="MergeFrom(CodedInputStream, ExtensionRegistry, IBuilder)" /> + /// but parses a single field. + /// </summary> + /// <param name="input">The input to read the field from</param> + /// <param name="extensionRegistry">Registry to use when an extension field is encountered</param> + /// <param name="builder">Builder to merge field into, if it's a known field</param> + /// <param name="tag">The tag, which should already have been read from the input</param> + /// <returns>true unless the tag is an end-group tag</returns> + internal bool MergeFieldFrom(CodedInputStream input, + ExtensionRegistry extensionRegistry, IBuilder builder, uint tag) { + + if (DescriptorProtoFile.Bootstrapping) { + return MergeFieldFrom(tag, input); + } + + MessageDescriptor type = builder.DescriptorForType; + if (type.Options.MessageSetWireFormat && tag == WireFormat.MessageSetTag.ItemStart) { + MergeMessageSetExtensionFromCodedStream(input, extensionRegistry, builder); + return true; + } + + WireFormat.WireType wireType = WireFormat.GetTagWireType(tag); + int fieldNumber = WireFormat.GetTagFieldNumber(tag); + + FieldDescriptor field; + IMessage defaultFieldInstance = null; + + if (type.IsExtensionNumber(fieldNumber)) { + ExtensionInfo extension = extensionRegistry[type, fieldNumber]; + if (extension == null) { + field = null; + } else { + field = extension.Descriptor; + defaultFieldInstance = extension.DefaultInstance; + } + } else { + field = type.FindFieldByNumber(fieldNumber); + } + + // Unknown field or wrong wire type. Skip. + if (field == null || wireType != WireFormat.GetWireType(field.FieldType)) { + return MergeFieldFrom(tag, input); + } + + object value; + switch (field.FieldType) { + case FieldType.Group: + case FieldType.Message: { + IBuilder subBuilder; + if (defaultFieldInstance != null) { + subBuilder = defaultFieldInstance.WeakCreateBuilderForType(); + } else { + subBuilder = builder.CreateBuilderForField(field); + } + if (!field.IsRepeated) { + subBuilder.WeakMergeFrom((IMessage)builder[field]); + } + if (field.FieldType == FieldType.Group) { + input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry); + } else { + input.ReadMessage(subBuilder, extensionRegistry); + } + value = subBuilder.WeakBuild(); + break; + } + case FieldType.Enum: { + int rawValue = input.ReadEnum(); + value = field.EnumType.FindValueByNumber(rawValue); + // If the number isn't recognized as a valid value for this enum, + // drop it. + if (value == null) { + MergeVarintField(fieldNumber, (ulong)rawValue); + return true; + } + break; + } + default: + value = input.ReadPrimitiveField(field.FieldType); + break; + } + if (field.IsRepeated) { + builder.WeakAddRepeatedField(field, value); + } else { + builder[field] = value; + } + return true; + } + + /// <summary> + /// Called by MergeFieldFrom to parse a MessageSet extension. + /// </summary> + private void MergeMessageSetExtensionFromCodedStream(CodedInputStream input, + ExtensionRegistry extensionRegistry, IBuilder builder) { + MessageDescriptor type = builder.DescriptorForType; + + // The wire format for MessageSet is: + // message MessageSet { + // repeated group Item = 1 { + // required int32 typeId = 2; + // required bytes message = 3; + // } + // } + // "typeId" is the extension's field number. The extension can only be + // a message type, where "message" contains the encoded bytes of that + // message. + // + // In practice, we will probably never see a MessageSet item in which + // the message appears before the type ID, or where either field does not + // appear exactly once. However, in theory such cases are valid, so we + // should be prepared to accept them. + + int typeId = 0; + ByteString rawBytes = null; // If we encounter "message" before "typeId" + IBuilder subBuilder = null; + FieldDescriptor field = null; + + while (true) { + uint tag = input.ReadTag(); + if (tag == 0) { + break; + } + + if (tag == WireFormat.MessageSetTag.TypeID) { + typeId = input.ReadInt32(); + // Zero is not a valid type ID. + if (typeId != 0) { + ExtensionInfo extension = extensionRegistry[type, typeId]; + if (extension != null) { + field = extension.Descriptor; + subBuilder = extension.DefaultInstance.WeakCreateBuilderForType(); + IMessage originalMessage = (IMessage)builder[field]; + if (originalMessage != null) { + subBuilder.WeakMergeFrom(originalMessage); + } + if (rawBytes != null) { + // We already encountered the message. Parse it now. + // TODO(jonskeet): Check this is okay. It's subtly different from the Java, as it doesn't create an input stream from rawBytes. + // In fact, why don't we just call MergeFrom(rawBytes)? And what about the extension registry? + subBuilder.WeakMergeFrom(rawBytes.CreateCodedInput()); + rawBytes = null; + } + } else { + // Unknown extension number. If we already saw data, put it + // in rawBytes. + if (rawBytes != null) { + MergeField(typeId, UnknownField.CreateBuilder().AddLengthDelimited(rawBytes).Build()); + rawBytes = null; + } + } + } + } else if (tag == WireFormat.MessageSetTag.Message) { + if (typeId == 0) { + // We haven't seen a type ID yet, so we have to store the raw bytes for now. + rawBytes = input.ReadBytes(); + } else if (subBuilder == null) { + // We don't know how to parse this. Ignore it. + MergeField(typeId, UnknownField.CreateBuilder().AddLengthDelimited(input.ReadBytes()).Build()); + } else { + // We already know the type, so we can parse directly from the input + // with no copying. Hooray! + input.ReadMessage(subBuilder, extensionRegistry); + } + } else { + // Unknown tag. Skip it. + if (!input.SkipField(tag)) { + break; // end of group + } + } + } + + input.CheckLastTagWas(WireFormat.MessageSetTag.ItemEnd); + + if (subBuilder != null) { + builder[field] = subBuilder.WeakBuild(); + } + } + } + } +} diff --git a/src/ProtocolBuffers/WireFormat.cs b/src/ProtocolBuffers/WireFormat.cs new file mode 100644 index 00000000..0ea93322 --- /dev/null +++ b/src/ProtocolBuffers/WireFormat.cs @@ -0,0 +1,122 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. +// http://code.google.com/p/protobuf/ +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +using System; +using System.Reflection; +using Google.ProtocolBuffers.Descriptors; +using System.Collections.Generic; +using Google.ProtocolBuffers.Collections; +namespace Google.ProtocolBuffers { + + /// <summary> + /// This class is used internally by the Protocol Buffer Library and generated + /// message implementations. It is public only for the sake of those generated + /// messages. Others should not use this class directly. + /// <para> + /// This class contains constants and helper functions useful for dealing with + /// the Protocol Buffer wire format. + /// </para> + /// </summary> + public static class WireFormat { + public enum WireType : uint { + Varint = 0, + Fixed64 = 1, + LengthDelimited = 2, + StartGroup = 3, + EndGroup = 4, + Fixed32 = 5 + } + + internal static class MessageSetField { + internal const int Item = 1; + internal const int TypeID = 2; + internal const int Message = 3; + } + + internal static class MessageSetTag { + internal static readonly uint ItemStart = MakeTag(MessageSetField.Item, WireType.StartGroup); + internal static readonly uint ItemEnd = MakeTag(MessageSetField.Item, WireType.EndGroup); + internal static readonly uint TypeID = MakeTag(MessageSetField.TypeID, WireType.Varint); + internal static readonly uint Message = MakeTag(MessageSetField.Message, WireType.LengthDelimited); + } + + private const int TagTypeBits = 3; + private const uint TagTypeMask = (1 << TagTypeBits) - 1; + + /// <summary> + /// Given a tag value, determines the wire type (lower 3 bits). + /// </summary> + public static WireType GetTagWireType(uint tag) { + return (WireType) (tag & TagTypeMask); + } + + /// <summary> + /// Given a tag value, determines the field number (the upper 29 bits). + /// </summary> + public static int GetTagFieldNumber(uint tag) { + return (int) tag >> TagTypeBits; + } + + /// <summary> + /// Makes a tag value given a field number and wire type. + /// TODO(jonskeet): Should we just have a Tag structure? + /// </summary> + public static uint MakeTag(int fieldNumber, WireType wireType) { + return (uint) (fieldNumber << TagTypeBits) | (uint) wireType; + } + + /// <summary> + /// Converts a field type to its wire type. Done with a switch for the sake + /// of speed - this is significantly faster than a dictionary lookup. + /// </summary> + public static WireType GetWireType(FieldType fieldType) { + switch (fieldType) { + case FieldType.Double: + return WireType.Fixed64; + case FieldType.Float: + return WireType.Fixed32; + case FieldType.Int64: + case FieldType.UInt64: + case FieldType.Int32: + return WireType.Varint; + case FieldType.Fixed64: + return WireType.Fixed64; + case FieldType.Fixed32: + return WireType.Fixed32; + case FieldType.Bool: + return WireType.Varint; + case FieldType.String: + return WireType.LengthDelimited; + case FieldType.Group: + return WireType.StartGroup; + case FieldType.Message: + case FieldType.Bytes: + return WireType.LengthDelimited; + case FieldType.UInt32: + return WireType.Varint; + case FieldType.SFixed32: + return WireType.Fixed32; + case FieldType.SFixed64: + return WireType.Fixed64; + case FieldType.SInt32: + case FieldType.SInt64: + case FieldType.Enum: + return WireType.Varint; + default: + throw new ArgumentOutOfRangeException("No such field type"); + } + } + } +} |