diff options
author | Jon Skeet <skeet@pobox.com> | 2015-06-26 20:47:35 +0100 |
---|---|---|
committer | Jon Skeet <skeet@pobox.com> | 2015-06-26 20:47:35 +0100 |
commit | 6b01539dfc1b4d4cefadc4cfdc79ff17293b84be (patch) | |
tree | 5c66e975d4594559a7fd08f7fbb35afc905aebb4 | |
parent | 68a4ee267f1999a5fc53678f7bb598c5c06f2f2e (diff) | |
parent | 286edc0fc2e52ed52ba08d5c572b4f125665d788 (diff) | |
download | protobuf-6b01539dfc1b4d4cefadc4cfdc79ff17293b84be.tar.gz protobuf-6b01539dfc1b4d4cefadc4cfdc79ff17293b84be.tar.bz2 protobuf-6b01539dfc1b4d4cefadc4cfdc79ff17293b84be.zip |
Merge pull request #543 from jskeet/proto3-map
Proto3 map support for C#
35 files changed, 8878 insertions, 102 deletions
diff --git a/cmake/libprotoc.cmake b/cmake/libprotoc.cmake index e9e88af5..8bf0a1f3 100644 --- a/cmake/libprotoc.cmake +++ b/cmake/libprotoc.cmake @@ -19,6 +19,7 @@ set(libprotoc_files ${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_field_base.cc ${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_generator.cc ${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_helpers.cc + ${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_map_field.cc ${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_message.cc ${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_message_field.cc ${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc diff --git a/csharp/generate_protos.sh b/csharp/generate_protos.sh index 60bc2813..e861f16f 100755 --- a/csharp/generate_protos.sh +++ b/csharp/generate_protos.sh @@ -43,10 +43,12 @@ $PROTOC -Isrc --csharp_out=csharp/src/ProtocolBuffers/DescriptorProtos \ rm src/google/protobuf/descriptor_proto_file.proto $PROTOC -Isrc --csharp_out=csharp/src/ProtocolBuffers.Test/TestProtos \ + src/google/protobuf/map_unittest_proto3.proto \ src/google/protobuf/unittest_proto3.proto \ src/google/protobuf/unittest_import_proto3.proto \ src/google/protobuf/unittest_import_public_proto3.proto + $PROTOC -Icsharp/protos/extest --csharp_out=csharp/src/ProtocolBuffers.Test/TestProtos \ csharp/protos/extest/unittest_issues.proto diff --git a/csharp/src/AddressBook/Addressbook.cs b/csharp/src/AddressBook/Addressbook.cs index 2fb6be83..1d8b8f10 100644 --- a/csharp/src/AddressBook/Addressbook.cs +++ b/csharp/src/AddressBook/Addressbook.cs @@ -155,7 +155,7 @@ namespace Google.ProtocolBuffers.Examples.AddressBook { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); if (Id != 0) hash ^= Id.GetHashCode(); if (Email.Length != 0) hash ^= Email.GetHashCode(); @@ -200,6 +200,7 @@ namespace Google.ProtocolBuffers.Examples.AddressBook { } return size; } + public void MergeFrom(Person other) { if (other == null) { return; @@ -329,7 +330,7 @@ namespace Google.ProtocolBuffers.Examples.AddressBook { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Number.Length != 0) hash ^= Number.GetHashCode(); if (Type != global::Google.ProtocolBuffers.Examples.AddressBook.Person.Types.PhoneType.HOME) hash ^= Type.GetHashCode(); return hash; @@ -356,6 +357,7 @@ namespace Google.ProtocolBuffers.Examples.AddressBook { } return size; } + public void MergeFrom(PhoneNumber other) { if (other == null) { return; @@ -456,7 +458,7 @@ namespace Google.ProtocolBuffers.Examples.AddressBook { } public override int GetHashCode() { - int hash = 0; + int hash = 1; hash ^= person_.GetHashCode(); return hash; } @@ -477,6 +479,7 @@ namespace Google.ProtocolBuffers.Examples.AddressBook { } return size; } + public void MergeFrom(AddressBook other) { if (other == null) { return; diff --git a/csharp/src/ProtocolBuffers.Test/Collections/MapFieldTest.cs b/csharp/src/ProtocolBuffers.Test/Collections/MapFieldTest.cs new file mode 100644 index 00000000..75f8ff2a --- /dev/null +++ b/csharp/src/ProtocolBuffers.Test/Collections/MapFieldTest.cs @@ -0,0 +1,354 @@ +#region Copyright notice and license +// Protocol Buffers - Google's data interchange format +// Copyright 2015 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#endregion + +using System; +using System.Collections.Generic; +using Google.Protobuf.TestProtos; +using NUnit.Framework; + +namespace Google.Protobuf.Collections +{ + /// <summary> + /// Tests for MapField which aren't reliant on the encoded format - + /// tests for serialization/deserialization are part of GeneratedMessageTest. + /// </summary> + public class MapFieldTest + { + // Protobuf-specific tests + [Test] + public void Freeze_FreezesMessages() + { + var message = new ForeignMessage { C = 20 }; + var map = new MapField<string, ForeignMessage> { { "x", message } }; + map.Freeze(); + Assert.IsTrue(message.IsFrozen); + } + + [Test] + public void Freeze_PreventsMutation() + { + var map = new MapField<string, string>(); + map.Freeze(); + Assert.IsTrue(map.IsFrozen); + Assert.IsTrue(map.IsReadOnly); + ICollection<KeyValuePair<string, string>> collection = map; + Assert.Throws<InvalidOperationException>(() => map["x"] = "y"); + Assert.Throws<InvalidOperationException>(() => map.Add("x", "y")); + Assert.Throws<InvalidOperationException>(() => map.Remove("x")); + Assert.Throws<InvalidOperationException>(() => map.Clear()); + Assert.Throws<InvalidOperationException>(() => collection.Add(NewKeyValuePair("x", "y"))); + Assert.Throws<InvalidOperationException>(() => collection.Remove(NewKeyValuePair("x", "y"))); + } + + [Test] + public void Clone_ReturnsNonFrozen() + { + var map = new MapField<string, string>(); + map.Freeze(); + var clone = map.Clone(); + clone.Add("x", "y"); + } + + [Test] + public void Clone_ClonesMessages() + { + var message = new ForeignMessage { C = 20 }; + var map = new MapField<string, ForeignMessage> { { "x", message } }; + var clone = map.Clone(); + map["x"].C = 30; + Assert.AreEqual(20, clone["x"].C); + } + + [Test] + public void Add_ForbidsNullKeys() + { + var map = new MapField<string, ForeignMessage>(); + Assert.Throws<ArgumentNullException>(() => map.Add(null, new ForeignMessage())); + } + + [Test] + public void Add_AcceptsNullMessageValues() + { + var map = new MapField<string, ForeignMessage>(); + map.Add("missing", null); + Assert.IsNull(map["missing"]); + } + + [Test] + public void Add_ForbidsNullStringValues() + { + var map = new MapField<string, string>(); + Assert.Throws<ArgumentNullException>(() => map.Add("missing", null)); + } + + [Test] + public void Add_ForbidsNullByteStringValues() + { + var map = new MapField<string, ByteString>(); + Assert.Throws<ArgumentNullException>(() => map.Add("missing", null)); + } + + [Test] + public void Indexer_ForbidsNullKeys() + { + var map = new MapField<string, ForeignMessage>(); + Assert.Throws<ArgumentNullException>(() => map[null] = new ForeignMessage()); + } + + [Test] + public void Indexer_AcceptsNullMessageValues() + { + var map = new MapField<string, ForeignMessage>(); + map["missing"] = null; + Assert.IsNull(map["missing"]); + } + + [Test] + public void Indexer_ForbidsNullStringValues() + { + var map = new MapField<string, string>(); + Assert.Throws<ArgumentNullException>(() => map["missing"] = null); + } + + [Test] + public void Indexer_ForbidsNullByteStringValues() + { + var map = new MapField<string, ByteString>(); + Assert.Throws<ArgumentNullException>(() => map["missing"] = null); + } + + [Test] + public void AddPreservesInsertionOrder() + { + var map = new MapField<string, string>(); + map.Add("a", "v1"); + map.Add("b", "v2"); + map.Add("c", "v3"); + map.Remove("b"); + map.Add("d", "v4"); + CollectionAssert.AreEqual(new[] { "a", "c", "d" }, map.Keys); + CollectionAssert.AreEqual(new[] { "v1", "v3", "v4" }, map.Values); + } + + [Test] + public void EqualityIsOrderInsensitive() + { + var map1 = new MapField<string, string>(); + map1.Add("a", "v1"); + map1.Add("b", "v2"); + + var map2 = new MapField<string, string>(); + map2.Add("b", "v2"); + map2.Add("a", "v1"); + + EqualityTester.AssertEquality(map1, map2); + } + + [Test] + public void EqualityIsKeySensitive() + { + var map1 = new MapField<string, string>(); + map1.Add("first key", "v1"); + map1.Add("second key", "v2"); + + var map2 = new MapField<string, string>(); + map2.Add("third key", "v1"); + map2.Add("fourth key", "v2"); + + EqualityTester.AssertInequality(map1, map2); + } + + [Test] + public void EqualityIsValueSensitive() + { + // Note: Without some care, it's a little easier than one might + // hope to see hash collisions, but only in some environments... + var map1 = new MapField<string, string>(); + map1.Add("a", "first value"); + map1.Add("b", "second value"); + + var map2 = new MapField<string, string>(); + map2.Add("a", "third value"); + map2.Add("b", "fourth value"); + + EqualityTester.AssertInequality(map1, map2); + } + + [Test] + public void EqualityHandlesNullValues() + { + var map1 = new MapField<string, ForeignMessage>(); + map1.Add("a", new ForeignMessage { C = 10 }); + map1.Add("b", null); + + var map2 = new MapField<string, ForeignMessage>(); + map2.Add("a", new ForeignMessage { C = 10 }); + map2.Add("b", null); + + EqualityTester.AssertEquality(map1, map2); + // Check the null value isn't ignored entirely... + Assert.IsTrue(map1.Remove("b")); + EqualityTester.AssertInequality(map1, map2); + map1.Add("b", new ForeignMessage()); + EqualityTester.AssertInequality(map1, map2); + map1["b"] = null; + EqualityTester.AssertEquality(map1, map2); + } + + [Test] + public void Add_Dictionary() + { + var map1 = new MapField<string, string> + { + { "x", "y" }, + { "a", "b" } + }; + var map2 = new MapField<string, string> + { + { "before", "" }, + map1, + { "after", "" } + }; + var expected = new MapField<string, string> + { + { "before", "" }, + { "x", "y" }, + { "a", "b" }, + { "after", "" } + }; + Assert.AreEqual(expected, map2); + CollectionAssert.AreEqual(new[] { "before", "x", "a", "after" }, map2.Keys); + } + + // General IDictionary<TKey, TValue> behavior tests + [Test] + public void Add_KeyAlreadyExists() + { + var map = new MapField<string, string>(); + map.Add("foo", "bar"); + Assert.Throws<ArgumentException>(() => map.Add("foo", "baz")); + } + + [Test] + public void Add_Pair() + { + var map = new MapField<string, string>(); + ICollection<KeyValuePair<string, string>> collection = map; + collection.Add(NewKeyValuePair("x", "y")); + Assert.AreEqual("y", map["x"]); + Assert.Throws<ArgumentException>(() => collection.Add(NewKeyValuePair("x", "z"))); + } + + [Test] + public void Contains_Pair() + { + var map = new MapField<string, string> { { "x", "y" } }; + ICollection<KeyValuePair<string, string>> collection = map; + Assert.IsTrue(collection.Contains(NewKeyValuePair("x", "y"))); + Assert.IsFalse(collection.Contains(NewKeyValuePair("x", "z"))); + Assert.IsFalse(collection.Contains(NewKeyValuePair("z", "y"))); + } + + [Test] + public void Remove_Key() + { + var map = new MapField<string, string>(); + map.Add("foo", "bar"); + Assert.AreEqual(1, map.Count); + Assert.IsFalse(map.Remove("missing")); + Assert.AreEqual(1, map.Count); + Assert.IsTrue(map.Remove("foo")); + Assert.AreEqual(0, map.Count); + } + + [Test] + public void Remove_Pair() + { + var map = new MapField<string, string>(); + map.Add("foo", "bar"); + ICollection<KeyValuePair<string, string>> collection = map; + Assert.AreEqual(1, map.Count); + Assert.IsFalse(collection.Remove(NewKeyValuePair("wrong key", "bar"))); + Assert.AreEqual(1, map.Count); + Assert.IsFalse(collection.Remove(NewKeyValuePair("foo", "wrong value"))); + Assert.AreEqual(1, map.Count); + Assert.IsTrue(collection.Remove(NewKeyValuePair("foo", "bar"))); + Assert.AreEqual(0, map.Count); + Assert.Throws<ArgumentException>(() => collection.Remove(new KeyValuePair<string, string>(null, ""))); + } + + [Test] + public void CopyTo_Pair() + { + var map = new MapField<string, string>(); + map.Add("foo", "bar"); + ICollection<KeyValuePair<string, string>> collection = map; + KeyValuePair<string, string>[] array = new KeyValuePair<string, string>[3]; + collection.CopyTo(array, 1); + Assert.AreEqual(NewKeyValuePair("foo", "bar"), array[1]); + } + + [Test] + public void Clear() + { + var map = new MapField<string, string> { { "x", "y" } }; + Assert.AreEqual(1, map.Count); + map.Clear(); + Assert.AreEqual(0, map.Count); + map.Add("x", "y"); + Assert.AreEqual(1, map.Count); + } + + [Test] + public void Indexer_Get() + { + var map = new MapField<string, string> { { "x", "y" } }; + Assert.AreEqual("y", map["x"]); + Assert.Throws<KeyNotFoundException>(() => { var ignored = map["z"]; }); + } + + [Test] + public void Indexer_Set() + { + var map = new MapField<string, string>(); + map["x"] = "y"; + Assert.AreEqual("y", map["x"]); + map["x"] = "z"; // This won't throw, unlike Add. + Assert.AreEqual("z", map["x"]); + } + + private static KeyValuePair<TKey, TValue> NewKeyValuePair<TKey, TValue>(TKey key, TValue value) + { + return new KeyValuePair<TKey, TValue>(key, value); + } + } +} diff --git a/csharp/src/ProtocolBuffers.Test/RepeatedFieldTest.cs b/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs index c01cd8ff..29945c36 100644 --- a/csharp/src/ProtocolBuffers.Test/RepeatedFieldTest.cs +++ b/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs @@ -1,10 +1,9 @@ using System; using System.Collections.Generic; -using Google.Protobuf.Collections; using Google.Protobuf.TestProtos; using NUnit.Framework; -namespace Google.Protobuf +namespace Google.Protobuf.Collections { public class RepeatedFieldTest { diff --git a/csharp/src/ProtocolBuffers.Test/EqualityTester.cs b/csharp/src/ProtocolBuffers.Test/EqualityTester.cs new file mode 100644 index 00000000..816f2be1 --- /dev/null +++ b/csharp/src/ProtocolBuffers.Test/EqualityTester.cs @@ -0,0 +1,63 @@ +#region Copyright notice and license +// Protocol Buffers - Google's data interchange format +// Copyright 2015 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#endregion + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using NUnit.Framework; + +namespace Google.Protobuf +{ + /// <summary> + /// Helper methods when testing equality. NUnit's Assert.AreEqual and + /// Assert.AreNotEqual methods try to be clever with collections, which can + /// be annoying... + /// </summary> + internal static class EqualityTester + { + public static void AssertEquality<T>(T first, T second) where T : IEquatable<T> + { + Assert.IsTrue(first.Equals(second)); + Assert.AreEqual(first.GetHashCode(), second.GetHashCode()); + } + + public static void AssertInequality<T>(T first, T second) where T : IEquatable<T> + { + Assert.IsFalse(first.Equals(second)); + // While this isn't a requirement, the chances of this test failing due to + // coincidence rather than a bug are very small. + Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode()); + } + } +} diff --git a/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs b/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs new file mode 100644 index 00000000..e2b8e3ef --- /dev/null +++ b/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs @@ -0,0 +1,149 @@ +#region Copyright notice and license +// Protocol Buffers - Google's data interchange format +// Copyright 2015 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#endregion + +using System.Collections.Generic; +using System.IO; +using Google.Protobuf.TestProtos; +using NUnit.Framework; + +namespace Google.Protobuf +{ + public class FieldCodecTest + { + private static readonly List<ICodecTestData> Codecs = new List<ICodecTestData> + { + new FieldCodecTestData<bool>(FieldCodec.ForBool(100), true, "Bool"), + new FieldCodecTestData<string>(FieldCodec.ForString(100), "sample", "String"), + new FieldCodecTestData<ByteString>(FieldCodec.ForBytes(100), ByteString.CopyFrom(1, 2, 3), "Bytes"), + new FieldCodecTestData<int>(FieldCodec.ForInt32(100), -1000, "Int32"), + new FieldCodecTestData<int>(FieldCodec.ForSInt32(100), -1000, "SInt32"), + new FieldCodecTestData<int>(FieldCodec.ForSFixed32(100), -1000, "SFixed32"), + new FieldCodecTestData<uint>(FieldCodec.ForUInt32(100), 1234, "UInt32"), + new FieldCodecTestData<uint>(FieldCodec.ForFixed32(100), 1234, "Fixed32"), + new FieldCodecTestData<long>(FieldCodec.ForInt64(100), -1000, "Int64"), + new FieldCodecTestData<long>(FieldCodec.ForSInt64(100), -1000, "SInt64"), + new FieldCodecTestData<long>(FieldCodec.ForSFixed64(100), -1000, "SFixed64"), + new FieldCodecTestData<ulong>(FieldCodec.ForUInt64(100), 1234, "UInt64"), + new FieldCodecTestData<ulong>(FieldCodec.ForFixed64(100), 1234, "Fixed64"), + new FieldCodecTestData<float>(FieldCodec.ForFloat(100), 1234.5f, "Float"), + new FieldCodecTestData<double>(FieldCodec.ForDouble(100), 1234567890.5d, "Double"), + new FieldCodecTestData<ForeignEnum>( + FieldCodec.ForEnum(100, t => (int) t, t => (ForeignEnum) t), ForeignEnum.FOREIGN_BAZ, "Enum"), + new FieldCodecTestData<ForeignMessage>( + FieldCodec.ForMessage(100, ForeignMessage.Parser), new ForeignMessage { C = 10 }, "Message"), + }; + + [Test, TestCaseSource("Codecs")] + public void RoundTrip(ICodecTestData codec) + { + codec.TestRoundTrip(); + } + + [Test, TestCaseSource("Codecs")] + public void CalculateSize(ICodecTestData codec) + { + codec.TestCalculateSize(); + } + + [Test, TestCaseSource("Codecs")] + public void DefaultValue(ICodecTestData codec) + { + codec.TestDefaultValue(); + } + + public interface ICodecTestData + { + void TestRoundTrip(); + void TestCalculateSize(); + void TestDefaultValue(); + } + + public class FieldCodecTestData<T> : ICodecTestData + { + private readonly FieldCodec<T> codec; + private readonly T sampleValue; + private readonly string name; + + public FieldCodecTestData(FieldCodec<T> codec, T sampleValue, string name) + { + this.codec = codec; + this.sampleValue = sampleValue; + this.name = name; + } + + public void TestRoundTrip() + { + var stream = new MemoryStream(); + var codedOutput = CodedOutputStream.CreateInstance(stream); + codec.Write(codedOutput, sampleValue); + codedOutput.Flush(); + stream.Position = 0; + var codedInput = CodedInputStream.CreateInstance(stream); + uint tag; + Assert.IsTrue(codedInput.ReadTag(out tag)); + Assert.AreEqual(codec.Tag, tag); + Assert.AreEqual(sampleValue, codec.Read(codedInput)); + Assert.IsTrue(codedInput.IsAtEnd); + } + + public void TestCalculateSize() + { + var stream = new MemoryStream(); + var codedOutput = CodedOutputStream.CreateInstance(stream); + codec.Write(codedOutput, sampleValue); + codedOutput.Flush(); + Assert.AreEqual(stream.Position, codec.CalculateSize(sampleValue)); + } + + public void TestDefaultValue() + { + var stream = new MemoryStream(); + var codedOutput = CodedOutputStream.CreateInstance(stream); + codec.Write(codedOutput, codec.DefaultValue); + codedOutput.Flush(); + Assert.AreEqual(0, stream.Position); + Assert.AreEqual(0, codec.CalculateSize(codec.DefaultValue)); + if (typeof(T).IsValueType) + { + Assert.AreEqual(default(T), codec.DefaultValue); + } + } + + public string Description { get { return name; } } + + public override string ToString() + { + return name; + } + } + } +} diff --git a/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs index 26165428..f8668662 100644 --- a/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs +++ b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs @@ -1,4 +1,5 @@ using System;
+using System.IO;
using Google.Protobuf.TestProtos;
using NUnit.Framework;
@@ -10,6 +11,15 @@ namespace Google.Protobuf public class GeneratedMessageTest
{
[Test]
+ public void EmptyMessageFieldDistinctFromMissingMessageField()
+ {
+ // This demonstrates what we're really interested in...
+ var message1 = new TestAllTypes { SingleForeignMessage = new ForeignMessage() };
+ var message2 = new TestAllTypes(); // SingleForeignMessage is null
+ EqualityTester.AssertInequality(message1, message2);
+ }
+
+ [Test]
public void DefaultValues()
{
// Single fields
@@ -146,6 +156,206 @@ namespace Google.Protobuf Assert.AreEqual(message, parsed);
}
+ // Note that not every map within map_unittest_proto3 is used. They all go through very
+ // similar code paths. The fact that all maps are present is validation that we have codecs
+ // for every type.
+ [Test]
+ public void RoundTrip_Maps()
+ {
+ var message = new TestMap
+ {
+ MapBoolBool = {
+ { false, true },
+ { true, false }
+ },
+ MapInt32Bytes = {
+ { 5, ByteString.CopyFrom(6, 7, 8) },
+ { 25, ByteString.CopyFrom(1, 2, 3, 4, 5) },
+ { 10, ByteString.Empty }
+ },
+ MapInt32ForeignMessage = {
+ { 0, new ForeignMessage { C = 10 } },
+ { 5, null },
+ },
+ MapInt32Enum = {
+ { 1, MapEnum.MAP_ENUM_BAR },
+ { 2000, MapEnum.MAP_ENUM_FOO }
+ }
+ };
+
+ byte[] bytes = message.ToByteArray();
+ TestMap parsed = TestMap.Parser.ParseFrom(bytes);
+ Assert.AreEqual(message, parsed);
+ }
+
+ [Test]
+ public void MapWithEmptyEntry()
+ {
+ var message = new TestMap
+ {
+ MapInt32Bytes = { { 0, ByteString.Empty } }
+ };
+
+ byte[] bytes = message.ToByteArray();
+ Assert.AreEqual(2, bytes.Length); // Tag for field entry (1 byte), length of entry (0; 1 byte)
+
+ var parsed = TestMap.Parser.ParseFrom(bytes);
+ Assert.AreEqual(1, parsed.MapInt32Bytes.Count);
+ Assert.AreEqual(ByteString.Empty, parsed.MapInt32Bytes[0]);
+ }
+
+ [Test]
+ public void MapWithOnlyValue()
+ {
+ // Hand-craft the stream to contain a single entry with just a value.
+ var memoryStream = new MemoryStream();
+ var output = CodedOutputStream.CreateInstance(memoryStream);
+ output.WriteTag(TestMap.MapInt32ForeignMessageFieldNumber, WireFormat.WireType.LengthDelimited);
+ var nestedMessage = new ForeignMessage { C = 20 };
+ // Size of the entry (tag, size written by WriteMessage, data written by WriteMessage)
+ output.WriteRawVarint32((uint)(nestedMessage.CalculateSize() + 3));
+ output.WriteTag(2, WireFormat.WireType.LengthDelimited);
+ output.WriteMessage(nestedMessage);
+ output.Flush();
+
+ var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray());
+ Assert.AreEqual(nestedMessage, parsed.MapInt32ForeignMessage[0]);
+ }
+
+ [Test]
+ public void MapIgnoresExtraFieldsWithinEntryMessages()
+ {
+ // Hand-craft the stream to contain a single entry with three fields
+ var memoryStream = new MemoryStream();
+ var output = CodedOutputStream.CreateInstance(memoryStream);
+
+ output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited);
+
+ var key = 10; // Field 1
+ var value = 20; // Field 2
+ var extra = 30; // Field 3
+
+ // Each field can be represented in a single byte, with a single byte tag.
+ // Total message size: 6 bytes.
+ output.WriteRawVarint32(6);
+ output.WriteTag(1, WireFormat.WireType.Varint);
+ output.WriteInt32(key);
+ output.WriteTag(2, WireFormat.WireType.Varint);
+ output.WriteInt32(value);
+ output.WriteTag(3, WireFormat.WireType.Varint);
+ output.WriteInt32(extra);
+ output.Flush();
+
+ var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray());
+ Assert.AreEqual(value, parsed.MapInt32Int32[key]);
+ }
+
+ [Test]
+ public void MapFieldOrderIsIrrelevant()
+ {
+ var memoryStream = new MemoryStream();
+ var output = CodedOutputStream.CreateInstance(memoryStream);
+
+ output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited);
+
+ var key = 10;
+ var value = 20;
+
+ // Each field can be represented in a single byte, with a single byte tag.
+ // Total message size: 4 bytes.
+ output.WriteRawVarint32(4);
+ output.WriteTag(2, WireFormat.WireType.Varint);
+ output.WriteInt32(value);
+ output.WriteTag(1, WireFormat.WireType.Varint);
+ output.WriteInt32(key);
+ output.Flush();
+
+ var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray());
+ Assert.AreEqual(value, parsed.MapInt32Int32[key]);
+ }
+
+ [Test]
+ public void MapNonContiguousEntries()
+ {
+ var memoryStream = new MemoryStream();
+ var output = CodedOutputStream.CreateInstance(memoryStream);
+
+ // Message structure:
+ // Entry for MapInt32Int32
+ // Entry for MapStringString
+ // Entry for MapInt32Int32
+
+ // First entry
+ var key1 = 10;
+ var value1 = 20;
+ output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited);
+ output.WriteRawVarint32(4);
+ output.WriteTag(1, WireFormat.WireType.Varint);
+ output.WriteInt32(key1);
+ output.WriteTag(2, WireFormat.WireType.Varint);
+ output.WriteInt32(value1);
+
+ // Second entry
+ var key2 = "a";
+ var value2 = "b";
+ output.WriteTag(TestMap.MapStringStringFieldNumber, WireFormat.WireType.LengthDelimited);
+ output.WriteRawVarint32(6); // 3 bytes per entry: tag, size, character
+ output.WriteTag(1, WireFormat.WireType.LengthDelimited);
+ output.WriteString(key2);
+ output.WriteTag(2, WireFormat.WireType.LengthDelimited);
+ output.WriteString(value2);
+
+ // Third entry
+ var key3 = 15;
+ var value3 = 25;
+ output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited);
+ output.WriteRawVarint32(4);
+ output.WriteTag(1, WireFormat.WireType.Varint);
+ output.WriteInt32(key3);
+ output.WriteTag(2, WireFormat.WireType.Varint);
+ output.WriteInt32(value3);
+
+ output.Flush();
+ var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray());
+ var expected = new TestMap
+ {
+ MapInt32Int32 = { { key1, value1 }, { key3, value3 } },
+ MapStringString = { { key2, value2 } }
+ };
+ Assert.AreEqual(expected, parsed);
+ }
+
+ [Test]
+ public void DuplicateKeys_LastEntryWins()
+ {
+ var memoryStream = new MemoryStream();
+ var output = CodedOutputStream.CreateInstance(memoryStream);
+
+ var key = 10;
+ var value1 = 20;
+ var value2 = 30;
+
+ // First entry
+ output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited);
+ output.WriteRawVarint32(4);
+ output.WriteTag(1, WireFormat.WireType.Varint);
+ output.WriteInt32(key);
+ output.WriteTag(2, WireFormat.WireType.Varint);
+ output.WriteInt32(value1);
+
+ // Second entry - same key, different value
+ output.WriteTag(TestMap.MapInt32Int32FieldNumber, WireFormat.WireType.LengthDelimited);
+ output.WriteRawVarint32(4);
+ output.WriteTag(1, WireFormat.WireType.Varint);
+ output.WriteInt32(key);
+ output.WriteTag(2, WireFormat.WireType.Varint);
+ output.WriteInt32(value2);
+ output.Flush();
+
+ var parsed = TestMap.Parser.ParseFrom(memoryStream.ToArray());
+ Assert.AreEqual(value2, parsed.MapInt32Int32[key]);
+ }
+
[Test]
public void CloneSingleNonMessageValues()
{
diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj index 31095a5b..e90be51d 100644 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj +++ b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -74,8 +74,12 @@ <Compile Include="ByteStringTest.cs" />
<Compile Include="CodedInputStreamTest.cs" />
<Compile Include="CodedOutputStreamTest.cs" />
+ <Compile Include="EqualityTester.cs" />
+ <Compile Include="FieldCodecTest.cs" />
<Compile Include="GeneratedMessageTest.cs" />
- <Compile Include="RepeatedFieldTest.cs" />
+ <Compile Include="Collections\MapFieldTest.cs" />
+ <Compile Include="Collections\RepeatedFieldTest.cs" />
+ <Compile Include="TestProtos\MapUnittestProto3.cs" />
<Compile Include="TestProtos\UnittestImportProto3.cs" />
<Compile Include="TestProtos\UnittestImportPublicProto3.cs" />
<Compile Include="TestProtos\UnittestIssues.cs" />
@@ -99,9 +103,7 @@ <ItemGroup>
<Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
</ItemGroup>
- <ItemGroup>
- <Folder Include="Collections\" />
- </ItemGroup>
+ <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.
diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/MapUnittestProto3.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/MapUnittestProto3.cs new file mode 100644 index 00000000..54c8880c --- /dev/null +++ b/csharp/src/ProtocolBuffers.Test/TestProtos/MapUnittestProto3.cs @@ -0,0 +1,6938 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: google/protobuf/map_unittest_proto3.proto +#pragma warning disable 1591, 0612, 3021 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbd = global::Google.Protobuf.Descriptors; +using scg = global::System.Collections.Generic; +namespace Google.Protobuf.TestProtos { + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class MapUnittestProto3 { + + #region Static variables + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap> internal__static_protobuf_unittest_TestMap__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapInt32Int32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32Int32Entry> internal__static_protobuf_unittest_TestMap_MapInt32Int32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapInt64Int64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt64Int64Entry> internal__static_protobuf_unittest_TestMap_MapInt64Int64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapUint32Uint32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapUint32Uint32Entry> internal__static_protobuf_unittest_TestMap_MapUint32Uint32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapUint64Uint64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapUint64Uint64Entry> internal__static_protobuf_unittest_TestMap_MapUint64Uint64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapSint32Sint32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapSint32Sint32Entry> internal__static_protobuf_unittest_TestMap_MapSint32Sint32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapSint64Sint64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapSint64Sint64Entry> internal__static_protobuf_unittest_TestMap_MapSint64Sint64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapFixed32Fixed32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapFixed32Fixed32Entry> internal__static_protobuf_unittest_TestMap_MapFixed32Fixed32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapFixed64Fixed64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapFixed64Fixed64Entry> internal__static_protobuf_unittest_TestMap_MapFixed64Fixed64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapSfixed32Sfixed32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapSfixed32Sfixed32Entry> internal__static_protobuf_unittest_TestMap_MapSfixed32Sfixed32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapSfixed64Sfixed64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapSfixed64Sfixed64Entry> internal__static_protobuf_unittest_TestMap_MapSfixed64Sfixed64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapInt32FloatEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32FloatEntry> internal__static_protobuf_unittest_TestMap_MapInt32FloatEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapInt32DoubleEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32DoubleEntry> internal__static_protobuf_unittest_TestMap_MapInt32DoubleEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapBoolBoolEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapBoolBoolEntry> internal__static_protobuf_unittest_TestMap_MapBoolBoolEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapStringStringEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapStringStringEntry> internal__static_protobuf_unittest_TestMap_MapStringStringEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapInt32BytesEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32BytesEntry> internal__static_protobuf_unittest_TestMap_MapInt32BytesEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapInt32EnumEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32EnumEntry> internal__static_protobuf_unittest_TestMap_MapInt32EnumEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMap_MapInt32ForeignMessageEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32ForeignMessageEntry> internal__static_protobuf_unittest_TestMap_MapInt32ForeignMessageEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMapSubmessage__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMapSubmessage> internal__static_protobuf_unittest_TestMapSubmessage__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageMap__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMessageMap> internal__static_protobuf_unittest_TestMessageMap__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestMessageMap_MapInt32MessageEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMessageMap.Types.MapInt32MessageEntry> internal__static_protobuf_unittest_TestMessageMap_MapInt32MessageEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestSameTypeMap__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestSameTypeMap> internal__static_protobuf_unittest_TestSameTypeMap__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestSameTypeMap_Map1Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestSameTypeMap.Types.Map1Entry> internal__static_protobuf_unittest_TestSameTypeMap_Map1Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestSameTypeMap_Map2Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestSameTypeMap.Types.Map2Entry> internal__static_protobuf_unittest_TestSameTypeMap_Map2Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap> internal__static_protobuf_unittest_TestArenaMap__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapInt32Int32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32Int32Entry> internal__static_protobuf_unittest_TestArenaMap_MapInt32Int32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapInt64Int64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt64Int64Entry> internal__static_protobuf_unittest_TestArenaMap_MapInt64Int64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapUint32Uint32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapUint32Uint32Entry> internal__static_protobuf_unittest_TestArenaMap_MapUint32Uint32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapUint64Uint64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapUint64Uint64Entry> internal__static_protobuf_unittest_TestArenaMap_MapUint64Uint64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapSint32Sint32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapSint32Sint32Entry> internal__static_protobuf_unittest_TestArenaMap_MapSint32Sint32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapSint64Sint64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapSint64Sint64Entry> internal__static_protobuf_unittest_TestArenaMap_MapSint64Sint64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapFixed32Fixed32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapFixed32Fixed32Entry> internal__static_protobuf_unittest_TestArenaMap_MapFixed32Fixed32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapFixed64Fixed64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapFixed64Fixed64Entry> internal__static_protobuf_unittest_TestArenaMap_MapFixed64Fixed64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapSfixed32Sfixed32Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapSfixed32Sfixed32Entry> internal__static_protobuf_unittest_TestArenaMap_MapSfixed32Sfixed32Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapSfixed64Sfixed64Entry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapSfixed64Sfixed64Entry> internal__static_protobuf_unittest_TestArenaMap_MapSfixed64Sfixed64Entry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapInt32FloatEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32FloatEntry> internal__static_protobuf_unittest_TestArenaMap_MapInt32FloatEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapInt32DoubleEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32DoubleEntry> internal__static_protobuf_unittest_TestArenaMap_MapInt32DoubleEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapBoolBoolEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapBoolBoolEntry> internal__static_protobuf_unittest_TestArenaMap_MapBoolBoolEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapInt32EnumEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32EnumEntry> internal__static_protobuf_unittest_TestArenaMap_MapInt32EnumEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_TestArenaMap_MapInt32ForeignMessageEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32ForeignMessageEntry> internal__static_protobuf_unittest_TestArenaMap_MapInt32ForeignMessageEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_MessageContainingEnumCalledType__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType> internal__static_protobuf_unittest_MessageContainingEnumCalledType__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_MessageContainingEnumCalledType_TypeEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType.Types.TypeEntry> internal__static_protobuf_unittest_MessageContainingEnumCalledType_TypeEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_MessageContainingMapCalledEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.MessageContainingMapCalledEntry> internal__static_protobuf_unittest_MessageContainingMapCalledEntry__FieldAccessorTable; + internal static pbd::MessageDescriptor internal__static_protobuf_unittest_MessageContainingMapCalledEntry_EntryEntry__Descriptor; + internal static pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.MessageContainingMapCalledEntry.Types.EntryEntry> internal__static_protobuf_unittest_MessageContainingMapCalledEntry_EntryEntry__FieldAccessorTable; + #endregion + #region Descriptor + public static pbd::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbd::FileDescriptor descriptor; + + static MapUnittestProto3() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Cilnb29nbGUvcHJvdG9idWYvbWFwX3VuaXR0ZXN0X3Byb3RvMy5wcm90bxIR", + "cHJvdG9idWZfdW5pdHRlc3QaJWdvb2dsZS9wcm90b2J1Zi91bml0dGVzdF9w", + "cm90bzMucHJvdG8ilhIKB1Rlc3RNYXASRgoPbWFwX2ludDMyX2ludDMyGAEg", + "AygLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVzdE1hcC5NYXBJbnQzMkludDMy", + "RW50cnkSRgoPbWFwX2ludDY0X2ludDY0GAIgAygLMi0ucHJvdG9idWZfdW5p", + "dHRlc3QuVGVzdE1hcC5NYXBJbnQ2NEludDY0RW50cnkSSgoRbWFwX3VpbnQz", + "Ml91aW50MzIYAyADKAsyLy5wcm90b2J1Zl91bml0dGVzdC5UZXN0TWFwLk1h", + "cFVpbnQzMlVpbnQzMkVudHJ5EkoKEW1hcF91aW50NjRfdWludDY0GAQgAygL", + "Mi8ucHJvdG9idWZfdW5pdHRlc3QuVGVzdE1hcC5NYXBVaW50NjRVaW50NjRF", + "bnRyeRJKChFtYXBfc2ludDMyX3NpbnQzMhgFIAMoCzIvLnByb3RvYnVmX3Vu", + "aXR0ZXN0LlRlc3RNYXAuTWFwU2ludDMyU2ludDMyRW50cnkSSgoRbWFwX3Np", + "bnQ2NF9zaW50NjQYBiADKAsyLy5wcm90b2J1Zl91bml0dGVzdC5UZXN0TWFw", + "Lk1hcFNpbnQ2NFNpbnQ2NEVudHJ5Ek4KE21hcF9maXhlZDMyX2ZpeGVkMzIY", + "ByADKAsyMS5wcm90b2J1Zl91bml0dGVzdC5UZXN0TWFwLk1hcEZpeGVkMzJG", + "aXhlZDMyRW50cnkSTgoTbWFwX2ZpeGVkNjRfZml4ZWQ2NBgIIAMoCzIxLnBy", + "b3RvYnVmX3VuaXR0ZXN0LlRlc3RNYXAuTWFwRml4ZWQ2NEZpeGVkNjRFbnRy", + "eRJSChVtYXBfc2ZpeGVkMzJfc2ZpeGVkMzIYCSADKAsyMy5wcm90b2J1Zl91", + "bml0dGVzdC5UZXN0TWFwLk1hcFNmaXhlZDMyU2ZpeGVkMzJFbnRyeRJSChVt", + "YXBfc2ZpeGVkNjRfc2ZpeGVkNjQYCiADKAsyMy5wcm90b2J1Zl91bml0dGVz", + "dC5UZXN0TWFwLk1hcFNmaXhlZDY0U2ZpeGVkNjRFbnRyeRJGCg9tYXBfaW50", + "MzJfZmxvYXQYCyADKAsyLS5wcm90b2J1Zl91bml0dGVzdC5UZXN0TWFwLk1h", + "cEludDMyRmxvYXRFbnRyeRJIChBtYXBfaW50MzJfZG91YmxlGAwgAygLMi4u", + "cHJvdG9idWZfdW5pdHRlc3QuVGVzdE1hcC5NYXBJbnQzMkRvdWJsZUVudHJ5", + "EkIKDW1hcF9ib29sX2Jvb2wYDSADKAsyKy5wcm90b2J1Zl91bml0dGVzdC5U", + "ZXN0TWFwLk1hcEJvb2xCb29sRW50cnkSSgoRbWFwX3N0cmluZ19zdHJpbmcY", + "DiADKAsyLy5wcm90b2J1Zl91bml0dGVzdC5UZXN0TWFwLk1hcFN0cmluZ1N0", + "cmluZ0VudHJ5EkYKD21hcF9pbnQzMl9ieXRlcxgPIAMoCzItLnByb3RvYnVm", + "X3VuaXR0ZXN0LlRlc3RNYXAuTWFwSW50MzJCeXRlc0VudHJ5EkQKDm1hcF9p", + "bnQzMl9lbnVtGBAgAygLMiwucHJvdG9idWZfdW5pdHRlc3QuVGVzdE1hcC5N", + "YXBJbnQzMkVudW1FbnRyeRJZChltYXBfaW50MzJfZm9yZWlnbl9tZXNzYWdl", + "GBEgAygLMjYucHJvdG9idWZfdW5pdHRlc3QuVGVzdE1hcC5NYXBJbnQzMkZv", + "cmVpZ25NZXNzYWdlRW50cnkaNAoSTWFwSW50MzJJbnQzMkVudHJ5EgsKA2tl", + "eRgBIAEoBRINCgV2YWx1ZRgCIAEoBToCOAEaNAoSTWFwSW50NjRJbnQ2NEVu", + "dHJ5EgsKA2tleRgBIAEoAxINCgV2YWx1ZRgCIAEoAzoCOAEaNgoUTWFwVWlu", + "dDMyVWludDMyRW50cnkSCwoDa2V5GAEgASgNEg0KBXZhbHVlGAIgASgNOgI4", + "ARo2ChRNYXBVaW50NjRVaW50NjRFbnRyeRILCgNrZXkYASABKAQSDQoFdmFs", + "dWUYAiABKAQ6AjgBGjYKFE1hcFNpbnQzMlNpbnQzMkVudHJ5EgsKA2tleRgB", + "IAEoERINCgV2YWx1ZRgCIAEoEToCOAEaNgoUTWFwU2ludDY0U2ludDY0RW50", + "cnkSCwoDa2V5GAEgASgSEg0KBXZhbHVlGAIgASgSOgI4ARo4ChZNYXBGaXhl", + "ZDMyRml4ZWQzMkVudHJ5EgsKA2tleRgBIAEoBxINCgV2YWx1ZRgCIAEoBzoC", + "OAEaOAoWTWFwRml4ZWQ2NEZpeGVkNjRFbnRyeRILCgNrZXkYASABKAYSDQoF", + "dmFsdWUYAiABKAY6AjgBGjoKGE1hcFNmaXhlZDMyU2ZpeGVkMzJFbnRyeRIL", + "CgNrZXkYASABKA8SDQoFdmFsdWUYAiABKA86AjgBGjoKGE1hcFNmaXhlZDY0", + "U2ZpeGVkNjRFbnRyeRILCgNrZXkYASABKBASDQoFdmFsdWUYAiABKBA6AjgB", + "GjQKEk1hcEludDMyRmxvYXRFbnRyeRILCgNrZXkYASABKAUSDQoFdmFsdWUY", + "AiABKAI6AjgBGjUKE01hcEludDMyRG91YmxlRW50cnkSCwoDa2V5GAEgASgF", + "Eg0KBXZhbHVlGAIgASgBOgI4ARoyChBNYXBCb29sQm9vbEVudHJ5EgsKA2tl", + "eRgBIAEoCBINCgV2YWx1ZRgCIAEoCDoCOAEaNgoUTWFwU3RyaW5nU3RyaW5n", + "RW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ARo0ChJNYXBJ", + "bnQzMkJ5dGVzRW50cnkSCwoDa2V5GAEgASgFEg0KBXZhbHVlGAIgASgMOgI4", + "ARpPChFNYXBJbnQzMkVudW1FbnRyeRILCgNrZXkYASABKAUSKQoFdmFsdWUY", + "AiABKA4yGi5wcm90b2J1Zl91bml0dGVzdC5NYXBFbnVtOgI4ARpgChtNYXBJ", + "bnQzMkZvcmVpZ25NZXNzYWdlRW50cnkSCwoDa2V5GAEgASgFEjAKBXZhbHVl", + "GAIgASgLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbk1lc3NhZ2U6AjgB", + "IkEKEVRlc3RNYXBTdWJtZXNzYWdlEiwKCHRlc3RfbWFwGAEgASgLMhoucHJv", + "dG9idWZfdW5pdHRlc3QuVGVzdE1hcCK8AQoOVGVzdE1lc3NhZ2VNYXASUQoR", + "bWFwX2ludDMyX21lc3NhZ2UYASADKAsyNi5wcm90b2J1Zl91bml0dGVzdC5U", + "ZXN0TWVzc2FnZU1hcC5NYXBJbnQzMk1lc3NhZ2VFbnRyeRpXChRNYXBJbnQz", + "Mk1lc3NhZ2VFbnRyeRILCgNrZXkYASABKAUSLgoFdmFsdWUYAiABKAsyHy5w", + "cm90b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXM6AjgBIuMBCg9UZXN0U2Ft", + "ZVR5cGVNYXASOgoEbWFwMRgBIAMoCzIsLnByb3RvYnVmX3VuaXR0ZXN0LlRl", + "c3RTYW1lVHlwZU1hcC5NYXAxRW50cnkSOgoEbWFwMhgCIAMoCzIsLnByb3Rv", + "YnVmX3VuaXR0ZXN0LlRlc3RTYW1lVHlwZU1hcC5NYXAyRW50cnkaKwoJTWFw", + "MUVudHJ5EgsKA2tleRgBIAEoBRINCgV2YWx1ZRgCIAEoBToCOAEaKwoJTWFw", + "MkVudHJ5EgsKA2tleRgBIAEoBRINCgV2YWx1ZRgCIAEoBToCOAEi5BAKDFRl", + "c3RBcmVuYU1hcBJLCg9tYXBfaW50MzJfaW50MzIYASADKAsyMi5wcm90b2J1", + "Zl91bml0dGVzdC5UZXN0QXJlbmFNYXAuTWFwSW50MzJJbnQzMkVudHJ5EksK", + "D21hcF9pbnQ2NF9pbnQ2NBgCIAMoCzIyLnByb3RvYnVmX3VuaXR0ZXN0LlRl", + "c3RBcmVuYU1hcC5NYXBJbnQ2NEludDY0RW50cnkSTwoRbWFwX3VpbnQzMl91", + "aW50MzIYAyADKAsyNC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QXJlbmFNYXAu", + "TWFwVWludDMyVWludDMyRW50cnkSTwoRbWFwX3VpbnQ2NF91aW50NjQYBCAD", + "KAsyNC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QXJlbmFNYXAuTWFwVWludDY0", + "VWludDY0RW50cnkSTwoRbWFwX3NpbnQzMl9zaW50MzIYBSADKAsyNC5wcm90", + "b2J1Zl91bml0dGVzdC5UZXN0QXJlbmFNYXAuTWFwU2ludDMyU2ludDMyRW50", + "cnkSTwoRbWFwX3NpbnQ2NF9zaW50NjQYBiADKAsyNC5wcm90b2J1Zl91bml0", + "dGVzdC5UZXN0QXJlbmFNYXAuTWFwU2ludDY0U2ludDY0RW50cnkSUwoTbWFw", + "X2ZpeGVkMzJfZml4ZWQzMhgHIAMoCzI2LnByb3RvYnVmX3VuaXR0ZXN0LlRl", + "c3RBcmVuYU1hcC5NYXBGaXhlZDMyRml4ZWQzMkVudHJ5ElMKE21hcF9maXhl", + "ZDY0X2ZpeGVkNjQYCCADKAsyNi5wcm90b2J1Zl91bml0dGVzdC5UZXN0QXJl", + "bmFNYXAuTWFwRml4ZWQ2NEZpeGVkNjRFbnRyeRJXChVtYXBfc2ZpeGVkMzJf", + "c2ZpeGVkMzIYCSADKAsyOC5wcm90b2J1Zl91bml0dGVzdC5UZXN0QXJlbmFN", + "YXAuTWFwU2ZpeGVkMzJTZml4ZWQzMkVudHJ5ElcKFW1hcF9zZml4ZWQ2NF9z", + "Zml4ZWQ2NBgKIAMoCzI4LnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RBcmVuYU1h", + "cC5NYXBTZml4ZWQ2NFNmaXhlZDY0RW50cnkSSwoPbWFwX2ludDMyX2Zsb2F0", + "GAsgAygLMjIucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFyZW5hTWFwLk1hcElu", + "dDMyRmxvYXRFbnRyeRJNChBtYXBfaW50MzJfZG91YmxlGAwgAygLMjMucHJv", + "dG9idWZfdW5pdHRlc3QuVGVzdEFyZW5hTWFwLk1hcEludDMyRG91YmxlRW50", + "cnkSRwoNbWFwX2Jvb2xfYm9vbBgNIAMoCzIwLnByb3RvYnVmX3VuaXR0ZXN0", + "LlRlc3RBcmVuYU1hcC5NYXBCb29sQm9vbEVudHJ5EkkKDm1hcF9pbnQzMl9l", + "bnVtGA4gAygLMjEucHJvdG9idWZfdW5pdHRlc3QuVGVzdEFyZW5hTWFwLk1h", + "cEludDMyRW51bUVudHJ5El4KGW1hcF9pbnQzMl9mb3JlaWduX21lc3NhZ2UY", + "DyADKAsyOy5wcm90b2J1Zl91bml0dGVzdC5UZXN0QXJlbmFNYXAuTWFwSW50", + "MzJGb3JlaWduTWVzc2FnZUVudHJ5GjQKEk1hcEludDMySW50MzJFbnRyeRIL", + "CgNrZXkYASABKAUSDQoFdmFsdWUYAiABKAU6AjgBGjQKEk1hcEludDY0SW50", + "NjRFbnRyeRILCgNrZXkYASABKAMSDQoFdmFsdWUYAiABKAM6AjgBGjYKFE1h", + "cFVpbnQzMlVpbnQzMkVudHJ5EgsKA2tleRgBIAEoDRINCgV2YWx1ZRgCIAEo", + "DToCOAEaNgoUTWFwVWludDY0VWludDY0RW50cnkSCwoDa2V5GAEgASgEEg0K", + "BXZhbHVlGAIgASgEOgI4ARo2ChRNYXBTaW50MzJTaW50MzJFbnRyeRILCgNr", + "ZXkYASABKBESDQoFdmFsdWUYAiABKBE6AjgBGjYKFE1hcFNpbnQ2NFNpbnQ2", + "NEVudHJ5EgsKA2tleRgBIAEoEhINCgV2YWx1ZRgCIAEoEjoCOAEaOAoWTWFw", + "Rml4ZWQzMkZpeGVkMzJFbnRyeRILCgNrZXkYASABKAcSDQoFdmFsdWUYAiAB", + "KAc6AjgBGjgKFk1hcEZpeGVkNjRGaXhlZDY0RW50cnkSCwoDa2V5GAEgASgG", + "Eg0KBXZhbHVlGAIgASgGOgI4ARo6ChhNYXBTZml4ZWQzMlNmaXhlZDMyRW50", + "cnkSCwoDa2V5GAEgASgPEg0KBXZhbHVlGAIgASgPOgI4ARo6ChhNYXBTZml4", + "ZWQ2NFNmaXhlZDY0RW50cnkSCwoDa2V5GAEgASgQEg0KBXZhbHVlGAIgASgQ", + "OgI4ARo0ChJNYXBJbnQzMkZsb2F0RW50cnkSCwoDa2V5GAEgASgFEg0KBXZh", + "bHVlGAIgASgCOgI4ARo1ChNNYXBJbnQzMkRvdWJsZUVudHJ5EgsKA2tleRgB", + "IAEoBRINCgV2YWx1ZRgCIAEoAToCOAEaMgoQTWFwQm9vbEJvb2xFbnRyeRIL", + "CgNrZXkYASABKAgSDQoFdmFsdWUYAiABKAg6AjgBGk8KEU1hcEludDMyRW51", + "bUVudHJ5EgsKA2tleRgBIAEoBRIpCgV2YWx1ZRgCIAEoDjIaLnByb3RvYnVm", + "X3VuaXR0ZXN0Lk1hcEVudW06AjgBGmAKG01hcEludDMyRm9yZWlnbk1lc3Nh", + "Z2VFbnRyeRILCgNrZXkYASABKAUSMAoFdmFsdWUYAiABKAsyIS5wcm90b2J1", + "Zl91bml0dGVzdC5Gb3JlaWduTWVzc2FnZToCOAEi5AEKH01lc3NhZ2VDb250", + "YWluaW5nRW51bUNhbGxlZFR5cGUSSgoEdHlwZRgBIAMoCzI8LnByb3RvYnVm", + "X3VuaXR0ZXN0Lk1lc3NhZ2VDb250YWluaW5nRW51bUNhbGxlZFR5cGUuVHlw", + "ZUVudHJ5Gl8KCVR5cGVFbnRyeRILCgNrZXkYASABKAUSQQoFdmFsdWUYAiAB", + "KAsyMi5wcm90b2J1Zl91bml0dGVzdC5NZXNzYWdlQ29udGFpbmluZ0VudW1D", + "YWxsZWRUeXBlOgI4ASIUCgRUeXBlEgwKCFRZUEVfRk9PEAAinQEKH01lc3Nh", + "Z2VDb250YWluaW5nTWFwQ2FsbGVkRW50cnkSTAoFZW50cnkYASADKAsyPS5w", + "cm90b2J1Zl91bml0dGVzdC5NZXNzYWdlQ29udGFpbmluZ01hcENhbGxlZEVu", + "dHJ5LkVudHJ5RW50cnkaLAoKRW50cnlFbnRyeRILCgNrZXkYASABKAUSDQoF", + "dmFsdWUYAiABKAU6AjgBKj8KB01hcEVudW0SEAoMTUFQX0VOVU1fRk9PEAAS", + "EAoMTUFQX0VOVU1fQkFSEAESEAoMTUFQX0VOVU1fQkFaEAJCIPgBAaoCGkdv", + "b2dsZS5Qcm90b2J1Zi5UZXN0UHJvdG9zYgZwcm90bzM=")); + pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { + descriptor = root; + internal__static_protobuf_unittest_TestMap__Descriptor = Descriptor.MessageTypes[0]; + internal__static_protobuf_unittest_TestMap__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap>(internal__static_protobuf_unittest_TestMap__Descriptor, + new string[] { "MapInt32Int32", "MapInt64Int64", "MapUint32Uint32", "MapUint64Uint64", "MapSint32Sint32", "MapSint64Sint64", "MapFixed32Fixed32", "MapFixed64Fixed64", "MapSfixed32Sfixed32", "MapSfixed64Sfixed64", "MapInt32Float", "MapInt32Double", "MapBoolBool", "MapStringString", "MapInt32Bytes", "MapInt32Enum", "MapInt32ForeignMessage", }); + internal__static_protobuf_unittest_TestMap_MapInt32Int32Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[0]; + internal__static_protobuf_unittest_TestMap_MapInt32Int32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32Int32Entry>(internal__static_protobuf_unittest_TestMap_MapInt32Int32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapInt64Int64Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[1]; + internal__static_protobuf_unittest_TestMap_MapInt64Int64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt64Int64Entry>(internal__static_protobuf_unittest_TestMap_MapInt64Int64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapUint32Uint32Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[2]; + internal__static_protobuf_unittest_TestMap_MapUint32Uint32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapUint32Uint32Entry>(internal__static_protobuf_unittest_TestMap_MapUint32Uint32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapUint64Uint64Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[3]; + internal__static_protobuf_unittest_TestMap_MapUint64Uint64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapUint64Uint64Entry>(internal__static_protobuf_unittest_TestMap_MapUint64Uint64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapSint32Sint32Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[4]; + internal__static_protobuf_unittest_TestMap_MapSint32Sint32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapSint32Sint32Entry>(internal__static_protobuf_unittest_TestMap_MapSint32Sint32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapSint64Sint64Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[5]; + internal__static_protobuf_unittest_TestMap_MapSint64Sint64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapSint64Sint64Entry>(internal__static_protobuf_unittest_TestMap_MapSint64Sint64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapFixed32Fixed32Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[6]; + internal__static_protobuf_unittest_TestMap_MapFixed32Fixed32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapFixed32Fixed32Entry>(internal__static_protobuf_unittest_TestMap_MapFixed32Fixed32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapFixed64Fixed64Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[7]; + internal__static_protobuf_unittest_TestMap_MapFixed64Fixed64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapFixed64Fixed64Entry>(internal__static_protobuf_unittest_TestMap_MapFixed64Fixed64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapSfixed32Sfixed32Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[8]; + internal__static_protobuf_unittest_TestMap_MapSfixed32Sfixed32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapSfixed32Sfixed32Entry>(internal__static_protobuf_unittest_TestMap_MapSfixed32Sfixed32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapSfixed64Sfixed64Entry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[9]; + internal__static_protobuf_unittest_TestMap_MapSfixed64Sfixed64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapSfixed64Sfixed64Entry>(internal__static_protobuf_unittest_TestMap_MapSfixed64Sfixed64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapInt32FloatEntry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[10]; + internal__static_protobuf_unittest_TestMap_MapInt32FloatEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32FloatEntry>(internal__static_protobuf_unittest_TestMap_MapInt32FloatEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapInt32DoubleEntry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[11]; + internal__static_protobuf_unittest_TestMap_MapInt32DoubleEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32DoubleEntry>(internal__static_protobuf_unittest_TestMap_MapInt32DoubleEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapBoolBoolEntry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[12]; + internal__static_protobuf_unittest_TestMap_MapBoolBoolEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapBoolBoolEntry>(internal__static_protobuf_unittest_TestMap_MapBoolBoolEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapStringStringEntry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[13]; + internal__static_protobuf_unittest_TestMap_MapStringStringEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapStringStringEntry>(internal__static_protobuf_unittest_TestMap_MapStringStringEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapInt32BytesEntry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[14]; + internal__static_protobuf_unittest_TestMap_MapInt32BytesEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32BytesEntry>(internal__static_protobuf_unittest_TestMap_MapInt32BytesEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapInt32EnumEntry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[15]; + internal__static_protobuf_unittest_TestMap_MapInt32EnumEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32EnumEntry>(internal__static_protobuf_unittest_TestMap_MapInt32EnumEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMap_MapInt32ForeignMessageEntry__Descriptor = internal__static_protobuf_unittest_TestMap__Descriptor.NestedTypes[16]; + internal__static_protobuf_unittest_TestMap_MapInt32ForeignMessageEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMap.Types.MapInt32ForeignMessageEntry>(internal__static_protobuf_unittest_TestMap_MapInt32ForeignMessageEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestMapSubmessage__Descriptor = Descriptor.MessageTypes[1]; + internal__static_protobuf_unittest_TestMapSubmessage__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMapSubmessage>(internal__static_protobuf_unittest_TestMapSubmessage__Descriptor, + new string[] { "TestMap", }); + internal__static_protobuf_unittest_TestMessageMap__Descriptor = Descriptor.MessageTypes[2]; + internal__static_protobuf_unittest_TestMessageMap__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMessageMap>(internal__static_protobuf_unittest_TestMessageMap__Descriptor, + new string[] { "MapInt32Message", }); + internal__static_protobuf_unittest_TestMessageMap_MapInt32MessageEntry__Descriptor = internal__static_protobuf_unittest_TestMessageMap__Descriptor.NestedTypes[0]; + internal__static_protobuf_unittest_TestMessageMap_MapInt32MessageEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestMessageMap.Types.MapInt32MessageEntry>(internal__static_protobuf_unittest_TestMessageMap_MapInt32MessageEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestSameTypeMap__Descriptor = Descriptor.MessageTypes[3]; + internal__static_protobuf_unittest_TestSameTypeMap__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestSameTypeMap>(internal__static_protobuf_unittest_TestSameTypeMap__Descriptor, + new string[] { "Map1", "Map2", }); + internal__static_protobuf_unittest_TestSameTypeMap_Map1Entry__Descriptor = internal__static_protobuf_unittest_TestSameTypeMap__Descriptor.NestedTypes[0]; + internal__static_protobuf_unittest_TestSameTypeMap_Map1Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestSameTypeMap.Types.Map1Entry>(internal__static_protobuf_unittest_TestSameTypeMap_Map1Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestSameTypeMap_Map2Entry__Descriptor = internal__static_protobuf_unittest_TestSameTypeMap__Descriptor.NestedTypes[1]; + internal__static_protobuf_unittest_TestSameTypeMap_Map2Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestSameTypeMap.Types.Map2Entry>(internal__static_protobuf_unittest_TestSameTypeMap_Map2Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap__Descriptor = Descriptor.MessageTypes[4]; + internal__static_protobuf_unittest_TestArenaMap__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap>(internal__static_protobuf_unittest_TestArenaMap__Descriptor, + new string[] { "MapInt32Int32", "MapInt64Int64", "MapUint32Uint32", "MapUint64Uint64", "MapSint32Sint32", "MapSint64Sint64", "MapFixed32Fixed32", "MapFixed64Fixed64", "MapSfixed32Sfixed32", "MapSfixed64Sfixed64", "MapInt32Float", "MapInt32Double", "MapBoolBool", "MapInt32Enum", "MapInt32ForeignMessage", }); + internal__static_protobuf_unittest_TestArenaMap_MapInt32Int32Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[0]; + internal__static_protobuf_unittest_TestArenaMap_MapInt32Int32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32Int32Entry>(internal__static_protobuf_unittest_TestArenaMap_MapInt32Int32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapInt64Int64Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[1]; + internal__static_protobuf_unittest_TestArenaMap_MapInt64Int64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt64Int64Entry>(internal__static_protobuf_unittest_TestArenaMap_MapInt64Int64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapUint32Uint32Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[2]; + internal__static_protobuf_unittest_TestArenaMap_MapUint32Uint32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapUint32Uint32Entry>(internal__static_protobuf_unittest_TestArenaMap_MapUint32Uint32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapUint64Uint64Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[3]; + internal__static_protobuf_unittest_TestArenaMap_MapUint64Uint64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapUint64Uint64Entry>(internal__static_protobuf_unittest_TestArenaMap_MapUint64Uint64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapSint32Sint32Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[4]; + internal__static_protobuf_unittest_TestArenaMap_MapSint32Sint32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapSint32Sint32Entry>(internal__static_protobuf_unittest_TestArenaMap_MapSint32Sint32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapSint64Sint64Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[5]; + internal__static_protobuf_unittest_TestArenaMap_MapSint64Sint64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapSint64Sint64Entry>(internal__static_protobuf_unittest_TestArenaMap_MapSint64Sint64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapFixed32Fixed32Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[6]; + internal__static_protobuf_unittest_TestArenaMap_MapFixed32Fixed32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapFixed32Fixed32Entry>(internal__static_protobuf_unittest_TestArenaMap_MapFixed32Fixed32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapFixed64Fixed64Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[7]; + internal__static_protobuf_unittest_TestArenaMap_MapFixed64Fixed64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapFixed64Fixed64Entry>(internal__static_protobuf_unittest_TestArenaMap_MapFixed64Fixed64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapSfixed32Sfixed32Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[8]; + internal__static_protobuf_unittest_TestArenaMap_MapSfixed32Sfixed32Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapSfixed32Sfixed32Entry>(internal__static_protobuf_unittest_TestArenaMap_MapSfixed32Sfixed32Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapSfixed64Sfixed64Entry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[9]; + internal__static_protobuf_unittest_TestArenaMap_MapSfixed64Sfixed64Entry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapSfixed64Sfixed64Entry>(internal__static_protobuf_unittest_TestArenaMap_MapSfixed64Sfixed64Entry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapInt32FloatEntry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[10]; + internal__static_protobuf_unittest_TestArenaMap_MapInt32FloatEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32FloatEntry>(internal__static_protobuf_unittest_TestArenaMap_MapInt32FloatEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapInt32DoubleEntry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[11]; + internal__static_protobuf_unittest_TestArenaMap_MapInt32DoubleEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32DoubleEntry>(internal__static_protobuf_unittest_TestArenaMap_MapInt32DoubleEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapBoolBoolEntry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[12]; + internal__static_protobuf_unittest_TestArenaMap_MapBoolBoolEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapBoolBoolEntry>(internal__static_protobuf_unittest_TestArenaMap_MapBoolBoolEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapInt32EnumEntry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[13]; + internal__static_protobuf_unittest_TestArenaMap_MapInt32EnumEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32EnumEntry>(internal__static_protobuf_unittest_TestArenaMap_MapInt32EnumEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_TestArenaMap_MapInt32ForeignMessageEntry__Descriptor = internal__static_protobuf_unittest_TestArenaMap__Descriptor.NestedTypes[14]; + internal__static_protobuf_unittest_TestArenaMap_MapInt32ForeignMessageEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.TestArenaMap.Types.MapInt32ForeignMessageEntry>(internal__static_protobuf_unittest_TestArenaMap_MapInt32ForeignMessageEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_MessageContainingEnumCalledType__Descriptor = Descriptor.MessageTypes[5]; + internal__static_protobuf_unittest_MessageContainingEnumCalledType__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType>(internal__static_protobuf_unittest_MessageContainingEnumCalledType__Descriptor, + new string[] { "Type", }); + internal__static_protobuf_unittest_MessageContainingEnumCalledType_TypeEntry__Descriptor = internal__static_protobuf_unittest_MessageContainingEnumCalledType__Descriptor.NestedTypes[0]; + internal__static_protobuf_unittest_MessageContainingEnumCalledType_TypeEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType.Types.TypeEntry>(internal__static_protobuf_unittest_MessageContainingEnumCalledType_TypeEntry__Descriptor, + new string[] { "Key", "Value", }); + internal__static_protobuf_unittest_MessageContainingMapCalledEntry__Descriptor = Descriptor.MessageTypes[6]; + internal__static_protobuf_unittest_MessageContainingMapCalledEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.MessageContainingMapCalledEntry>(internal__static_protobuf_unittest_MessageContainingMapCalledEntry__Descriptor, + new string[] { "Entry", }); + internal__static_protobuf_unittest_MessageContainingMapCalledEntry_EntryEntry__Descriptor = internal__static_protobuf_unittest_MessageContainingMapCalledEntry__Descriptor.NestedTypes[0]; + internal__static_protobuf_unittest_MessageContainingMapCalledEntry_EntryEntry__FieldAccessorTable = + new pb::FieldAccess.FieldAccessorTable<global::Google.Protobuf.TestProtos.MessageContainingMapCalledEntry.Types.EntryEntry>(internal__static_protobuf_unittest_MessageContainingMapCalledEntry_EntryEntry__Descriptor, + new string[] { "Key", "Value", }); + }; + pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, + new pbd::FileDescriptor[] { + global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor, + }, assigner); + } + #endregion + + } + #region Enums + public enum MapEnum { + MAP_ENUM_FOO = 0, + MAP_ENUM_BAR = 1, + MAP_ENUM_BAZ = 2, + } + + #endregion + + #region Messages + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class TestMap : pb::IMessage<TestMap> { + private static readonly pb::MessageParser<TestMap> _parser = new pb::MessageParser<TestMap>(() => new TestMap()); + public static pb::MessageParser<TestMap> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "map_bool_bool", "map_fixed32_fixed32", "map_fixed64_fixed64", "map_int32_bytes", "map_int32_double", "map_int32_enum", "map_int32_float", "map_int32_foreign_message", "map_int32_int32", "map_int64_int64", "map_sfixed32_sfixed32", "map_sfixed64_sfixed64", "map_sint32_sint32", "map_sint64_sint64", "map_string_string", "map_uint32_uint32", "map_uint64_uint64" }; + private static readonly uint[] _fieldTags = new uint[] { 106, 58, 66, 122, 98, 130, 90, 138, 10, 18, 74, 82, 42, 50, 114, 26, 34 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<TestMap> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public TestMap() { } + + public TestMap(TestMap other) { + mapInt32Int32_ = other.mapInt32Int32_.Clone(); + mapInt64Int64_ = other.mapInt64Int64_.Clone(); + mapUint32Uint32_ = other.mapUint32Uint32_.Clone(); + mapUint64Uint64_ = other.mapUint64Uint64_.Clone(); + mapSint32Sint32_ = other.mapSint32Sint32_.Clone(); + mapSint64Sint64_ = other.mapSint64Sint64_.Clone(); + mapFixed32Fixed32_ = other.mapFixed32Fixed32_.Clone(); + mapFixed64Fixed64_ = other.mapFixed64Fixed64_.Clone(); + mapSfixed32Sfixed32_ = other.mapSfixed32Sfixed32_.Clone(); + mapSfixed64Sfixed64_ = other.mapSfixed64Sfixed64_.Clone(); + mapInt32Float_ = other.mapInt32Float_.Clone(); + mapInt32Double_ = other.mapInt32Double_.Clone(); + mapBoolBool_ = other.mapBoolBool_.Clone(); + mapStringString_ = other.mapStringString_.Clone(); + mapInt32Bytes_ = other.mapInt32Bytes_.Clone(); + mapInt32Enum_ = other.mapInt32Enum_.Clone(); + mapInt32ForeignMessage_ = other.mapInt32ForeignMessage_.Clone(); + } + + public TestMap Clone() { + return new TestMap(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + mapInt32Int32_.Freeze(); + mapInt64Int64_.Freeze(); + mapUint32Uint32_.Freeze(); + mapUint64Uint64_.Freeze(); + mapSint32Sint32_.Freeze(); + mapSint64Sint64_.Freeze(); + mapFixed32Fixed32_.Freeze(); + mapFixed64Fixed64_.Freeze(); + mapSfixed32Sfixed32_.Freeze(); + mapSfixed64Sfixed64_.Freeze(); + mapInt32Float_.Freeze(); + mapInt32Double_.Freeze(); + mapBoolBool_.Freeze(); + mapStringString_.Freeze(); + mapInt32Bytes_.Freeze(); + mapInt32Enum_.Freeze(); + mapInt32ForeignMessage_.Freeze(); + } + + public const int MapInt32Int32FieldNumber = 1; + private static readonly pbc::MapField<int, int>.Codec _map_mapInt32Int32_codec + = new pbc::MapField<int, int>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForInt32(16), 10); + private readonly pbc::MapField<int, int> mapInt32Int32_ = new pbc::MapField<int, int>(); + public pbc::MapField<int, int> MapInt32Int32 { + get { return mapInt32Int32_; } + } + + public const int MapInt64Int64FieldNumber = 2; + private static readonly pbc::MapField<long, long>.Codec _map_mapInt64Int64_codec + = new pbc::MapField<long, long>.Codec(pb::FieldCodec.ForInt64(8), pb::FieldCodec.ForInt64(16), 18); + private readonly pbc::MapField<long, long> mapInt64Int64_ = new pbc::MapField<long, long>(); + public pbc::MapField<long, long> MapInt64Int64 { + get { return mapInt64Int64_; } + } + + public const int MapUint32Uint32FieldNumber = 3; + private static readonly pbc::MapField<uint, uint>.Codec _map_mapUint32Uint32_codec + = new pbc::MapField<uint, uint>.Codec(pb::FieldCodec.ForUInt32(8), pb::FieldCodec.ForUInt32(16), 26); + private readonly pbc::MapField<uint, uint> mapUint32Uint32_ = new pbc::MapField<uint, uint>(); + public pbc::MapField<uint, uint> MapUint32Uint32 { + get { return mapUint32Uint32_; } + } + + public const int MapUint64Uint64FieldNumber = 4; + private static readonly pbc::MapField<ulong, ulong>.Codec _map_mapUint64Uint64_codec + = new pbc::MapField<ulong, ulong>.Codec(pb::FieldCodec.ForUInt64(8), pb::FieldCodec.ForUInt64(16), 34); + private readonly pbc::MapField<ulong, ulong> mapUint64Uint64_ = new pbc::MapField<ulong, ulong>(); + public pbc::MapField<ulong, ulong> MapUint64Uint64 { + get { return mapUint64Uint64_; } + } + + public const int MapSint32Sint32FieldNumber = 5; + private static readonly pbc::MapField<int, int>.Codec _map_mapSint32Sint32_codec + = new pbc::MapField<int, int>.Codec(pb::FieldCodec.ForSInt32(8), pb::FieldCodec.ForSInt32(16), 42); + private readonly pbc::MapField<int, int> mapSint32Sint32_ = new pbc::MapField<int, int>(); + public pbc::MapField<int, int> MapSint32Sint32 { + get { return mapSint32Sint32_; } + } + + public const int MapSint64Sint64FieldNumber = 6; + private static readonly pbc::MapField<long, long>.Codec _map_mapSint64Sint64_codec + = new pbc::MapField<long, long>.Codec(pb::FieldCodec.ForSInt64(8), pb::FieldCodec.ForSInt64(16), 50); + private readonly pbc::MapField<long, long> mapSint64Sint64_ = new pbc::MapField<long, long>(); + public pbc::MapField<long, long> MapSint64Sint64 { + get { return mapSint64Sint64_; } + } + + public const int MapFixed32Fixed32FieldNumber = 7; + private static readonly pbc::MapField<uint, uint>.Codec _map_mapFixed32Fixed32_codec + = new pbc::MapField<uint, uint>.Codec(pb::FieldCodec.ForFixed32(13), pb::FieldCodec.ForFixed32(21), 58); + private readonly pbc::MapField<uint, uint> mapFixed32Fixed32_ = new pbc::MapField<uint, uint>(); + public pbc::MapField<uint, uint> MapFixed32Fixed32 { + get { return mapFixed32Fixed32_; } + } + + public const int MapFixed64Fixed64FieldNumber = 8; + private static readonly pbc::MapField<ulong, ulong>.Codec _map_mapFixed64Fixed64_codec + = new pbc::MapField<ulong, ulong>.Codec(pb::FieldCodec.ForFixed64(9), pb::FieldCodec.ForFixed64(17), 66); + private readonly pbc::MapField<ulong, ulong> mapFixed64Fixed64_ = new pbc::MapField<ulong, ulong>(); + public pbc::MapField<ulong, ulong> MapFixed64Fixed64 { + get { return mapFixed64Fixed64_; } + } + + public const int MapSfixed32Sfixed32FieldNumber = 9; + private static readonly pbc::MapField<int, int>.Codec _map_mapSfixed32Sfixed32_codec + = new pbc::MapField<int, int>.Codec(pb::FieldCodec.ForSFixed32(13), pb::FieldCodec.ForSFixed32(21), 74); + private readonly pbc::MapField<int, int> mapSfixed32Sfixed32_ = new pbc::MapField<int, int>(); + public pbc::MapField<int, int> MapSfixed32Sfixed32 { + get { return mapSfixed32Sfixed32_; } + } + + public const int MapSfixed64Sfixed64FieldNumber = 10; + private static readonly pbc::MapField<long, long>.Codec _map_mapSfixed64Sfixed64_codec + = new pbc::MapField<long, long>.Codec(pb::FieldCodec.ForSFixed64(9), pb::FieldCodec.ForSFixed64(17), 82); + private readonly pbc::MapField<long, long> mapSfixed64Sfixed64_ = new pbc::MapField<long, long>(); + public pbc::MapField<long, long> MapSfixed64Sfixed64 { + get { return mapSfixed64Sfixed64_; } + } + + public const int MapInt32FloatFieldNumber = 11; + private static readonly pbc::MapField<int, float>.Codec _map_mapInt32Float_codec + = new pbc::MapField<int, float>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForFloat(21), 90); + private readonly pbc::MapField<int, float> mapInt32Float_ = new pbc::MapField<int, float>(); + public pbc::MapField<int, float> MapInt32Float { + get { return mapInt32Float_; } + } + + public const int MapInt32DoubleFieldNumber = 12; + private static readonly pbc::MapField<int, double>.Codec _map_mapInt32Double_codec + = new pbc::MapField<int, double>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForDouble(17), 98); + private readonly pbc::MapField<int, double> mapInt32Double_ = new pbc::MapField<int, double>(); + public pbc::MapField<int, double> MapInt32Double { + get { return mapInt32Double_; } + } + + public const int MapBoolBoolFieldNumber = 13; + private static readonly pbc::MapField<bool, bool>.Codec _map_mapBoolBool_codec + = new pbc::MapField<bool, bool>.Codec(pb::FieldCodec.ForBool(8), pb::FieldCodec.ForBool(16), 106); + private readonly pbc::MapField<bool, bool> mapBoolBool_ = new pbc::MapField<bool, bool>(); + public pbc::MapField<bool, bool> MapBoolBool { + get { return mapBoolBool_; } + } + + public const int MapStringStringFieldNumber = 14; + private static readonly pbc::MapField<string, string>.Codec _map_mapStringString_codec + = new pbc::MapField<string, string>.Codec(pb::FieldCodec.ForString(10), pb::FieldCodec.ForString(18), 114); + private readonly pbc::MapField<string, string> mapStringString_ = new pbc::MapField<string, string>(); + public pbc::MapField<string, string> MapStringString { + get { return mapStringString_; } + } + + public const int MapInt32BytesFieldNumber = 15; + private static readonly pbc::MapField<int, pb::ByteString>.Codec _map_mapInt32Bytes_codec + = new pbc::MapField<int, pb::ByteString>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForBytes(18), 122); + private readonly pbc::MapField<int, pb::ByteString> mapInt32Bytes_ = new pbc::MapField<int, pb::ByteString>(); + public pbc::MapField<int, pb::ByteString> MapInt32Bytes { + get { return mapInt32Bytes_; } + } + + public const int MapInt32EnumFieldNumber = 16; + private static readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum>.Codec _map_mapInt32Enum_codec + = new pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForEnum(16, x => (int) x, x => (global::Google.Protobuf.TestProtos.MapEnum) x), 130); + private readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum> mapInt32Enum_ = new pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum>(); + public pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum> MapInt32Enum { + get { return mapInt32Enum_; } + } + + public const int MapInt32ForeignMessageFieldNumber = 17; + private static readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage>.Codec _map_mapInt32ForeignMessage_codec + = new pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.TestProtos.ForeignMessage.Parser), 138); + private readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage> mapInt32ForeignMessage_ = new pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage>(); + public pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage> MapInt32ForeignMessage { + get { return mapInt32ForeignMessage_; } + } + + public override bool Equals(object other) { + return Equals(other as TestMap); + } + + public bool Equals(TestMap other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!MapInt32Int32.Equals(other.MapInt32Int32)) return false; + if (!MapInt64Int64.Equals(other.MapInt64Int64)) return false; + if (!MapUint32Uint32.Equals(other.MapUint32Uint32)) return false; + if (!MapUint64Uint64.Equals(other.MapUint64Uint64)) return false; + if (!MapSint32Sint32.Equals(other.MapSint32Sint32)) return false; + if (!MapSint64Sint64.Equals(other.MapSint64Sint64)) return false; + if (!MapFixed32Fixed32.Equals(other.MapFixed32Fixed32)) return false; + if (!MapFixed64Fixed64.Equals(other.MapFixed64Fixed64)) return false; + if (!MapSfixed32Sfixed32.Equals(other.MapSfixed32Sfixed32)) return false; + if (!MapSfixed64Sfixed64.Equals(other.MapSfixed64Sfixed64)) return false; + if (!MapInt32Float.Equals(other.MapInt32Float)) return false; + if (!MapInt32Double.Equals(other.MapInt32Double)) return false; + if (!MapBoolBool.Equals(other.MapBoolBool)) return false; + if (!MapStringString.Equals(other.MapStringString)) return false; + if (!MapInt32Bytes.Equals(other.MapInt32Bytes)) return false; + if (!MapInt32Enum.Equals(other.MapInt32Enum)) return false; + if (!MapInt32ForeignMessage.Equals(other.MapInt32ForeignMessage)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + hash ^= MapInt32Int32.GetHashCode(); + hash ^= MapInt64Int64.GetHashCode(); + hash ^= MapUint32Uint32.GetHashCode(); + hash ^= MapUint64Uint64.GetHashCode(); + hash ^= MapSint32Sint32.GetHashCode(); + hash ^= MapSint64Sint64.GetHashCode(); + hash ^= MapFixed32Fixed32.GetHashCode(); + hash ^= MapFixed64Fixed64.GetHashCode(); + hash ^= MapSfixed32Sfixed32.GetHashCode(); + hash ^= MapSfixed64Sfixed64.GetHashCode(); + hash ^= MapInt32Float.GetHashCode(); + hash ^= MapInt32Double.GetHashCode(); + hash ^= MapBoolBool.GetHashCode(); + hash ^= MapStringString.GetHashCode(); + hash ^= MapInt32Bytes.GetHashCode(); + hash ^= MapInt32Enum.GetHashCode(); + hash ^= MapInt32ForeignMessage.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + mapInt32Int32_.WriteTo(output, _map_mapInt32Int32_codec); + mapInt64Int64_.WriteTo(output, _map_mapInt64Int64_codec); + mapUint32Uint32_.WriteTo(output, _map_mapUint32Uint32_codec); + mapUint64Uint64_.WriteTo(output, _map_mapUint64Uint64_codec); + mapSint32Sint32_.WriteTo(output, _map_mapSint32Sint32_codec); + mapSint64Sint64_.WriteTo(output, _map_mapSint64Sint64_codec); + mapFixed32Fixed32_.WriteTo(output, _map_mapFixed32Fixed32_codec); + mapFixed64Fixed64_.WriteTo(output, _map_mapFixed64Fixed64_codec); + mapSfixed32Sfixed32_.WriteTo(output, _map_mapSfixed32Sfixed32_codec); + mapSfixed64Sfixed64_.WriteTo(output, _map_mapSfixed64Sfixed64_codec); + mapInt32Float_.WriteTo(output, _map_mapInt32Float_codec); + mapInt32Double_.WriteTo(output, _map_mapInt32Double_codec); + mapBoolBool_.WriteTo(output, _map_mapBoolBool_codec); + mapStringString_.WriteTo(output, _map_mapStringString_codec); + mapInt32Bytes_.WriteTo(output, _map_mapInt32Bytes_codec); + mapInt32Enum_.WriteTo(output, _map_mapInt32Enum_codec); + mapInt32ForeignMessage_.WriteTo(output, _map_mapInt32ForeignMessage_codec); + } + + public int CalculateSize() { + int size = 0; + size += mapInt32Int32_.CalculateSize(_map_mapInt32Int32_codec); + size += mapInt64Int64_.CalculateSize(_map_mapInt64Int64_codec); + size += mapUint32Uint32_.CalculateSize(_map_mapUint32Uint32_codec); + size += mapUint64Uint64_.CalculateSize(_map_mapUint64Uint64_codec); + size += mapSint32Sint32_.CalculateSize(_map_mapSint32Sint32_codec); + size += mapSint64Sint64_.CalculateSize(_map_mapSint64Sint64_codec); + size += mapFixed32Fixed32_.CalculateSize(_map_mapFixed32Fixed32_codec); + size += mapFixed64Fixed64_.CalculateSize(_map_mapFixed64Fixed64_codec); + size += mapSfixed32Sfixed32_.CalculateSize(_map_mapSfixed32Sfixed32_codec); + size += mapSfixed64Sfixed64_.CalculateSize(_map_mapSfixed64Sfixed64_codec); + size += mapInt32Float_.CalculateSize(_map_mapInt32Float_codec); + size += mapInt32Double_.CalculateSize(_map_mapInt32Double_codec); + size += mapBoolBool_.CalculateSize(_map_mapBoolBool_codec); + size += mapStringString_.CalculateSize(_map_mapStringString_codec); + size += mapInt32Bytes_.CalculateSize(_map_mapInt32Bytes_codec); + size += mapInt32Enum_.CalculateSize(_map_mapInt32Enum_codec); + size += mapInt32ForeignMessage_.CalculateSize(_map_mapInt32ForeignMessage_codec); + return size; + } + + public void MergeFrom(TestMap other) { + if (other == null) { + return; + } + mapInt32Int32_.Add(other.mapInt32Int32_); + mapInt64Int64_.Add(other.mapInt64Int64_); + mapUint32Uint32_.Add(other.mapUint32Uint32_); + mapUint64Uint64_.Add(other.mapUint64Uint64_); + mapSint32Sint32_.Add(other.mapSint32Sint32_); + mapSint64Sint64_.Add(other.mapSint64Sint64_); + mapFixed32Fixed32_.Add(other.mapFixed32Fixed32_); + mapFixed64Fixed64_.Add(other.mapFixed64Fixed64_); + mapSfixed32Sfixed32_.Add(other.mapSfixed32Sfixed32_); + mapSfixed64Sfixed64_.Add(other.mapSfixed64Sfixed64_); + mapInt32Float_.Add(other.mapInt32Float_); + mapInt32Double_.Add(other.mapInt32Double_); + mapBoolBool_.Add(other.mapBoolBool_); + mapStringString_.Add(other.mapStringString_); + mapInt32Bytes_.Add(other.mapInt32Bytes_); + mapInt32Enum_.Add(other.mapInt32Enum_); + mapInt32ForeignMessage_.Add(other.mapInt32ForeignMessage_); + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 10: { + mapInt32Int32_.AddEntriesFrom(input, _map_mapInt32Int32_codec); + break; + } + case 18: { + mapInt64Int64_.AddEntriesFrom(input, _map_mapInt64Int64_codec); + break; + } + case 26: { + mapUint32Uint32_.AddEntriesFrom(input, _map_mapUint32Uint32_codec); + break; + } + case 34: { + mapUint64Uint64_.AddEntriesFrom(input, _map_mapUint64Uint64_codec); + break; + } + case 42: { + mapSint32Sint32_.AddEntriesFrom(input, _map_mapSint32Sint32_codec); + break; + } + case 50: { + mapSint64Sint64_.AddEntriesFrom(input, _map_mapSint64Sint64_codec); + break; + } + case 58: { + mapFixed32Fixed32_.AddEntriesFrom(input, _map_mapFixed32Fixed32_codec); + break; + } + case 66: { + mapFixed64Fixed64_.AddEntriesFrom(input, _map_mapFixed64Fixed64_codec); + break; + } + case 74: { + mapSfixed32Sfixed32_.AddEntriesFrom(input, _map_mapSfixed32Sfixed32_codec); + break; + } + case 82: { + mapSfixed64Sfixed64_.AddEntriesFrom(input, _map_mapSfixed64Sfixed64_codec); + break; + } + case 90: { + mapInt32Float_.AddEntriesFrom(input, _map_mapInt32Float_codec); + break; + } + case 98: { + mapInt32Double_.AddEntriesFrom(input, _map_mapInt32Double_codec); + break; + } + case 106: { + mapBoolBool_.AddEntriesFrom(input, _map_mapBoolBool_codec); + break; + } + case 114: { + mapStringString_.AddEntriesFrom(input, _map_mapStringString_codec); + break; + } + case 122: { + mapInt32Bytes_.AddEntriesFrom(input, _map_mapInt32Bytes_codec); + break; + } + case 130: { + mapInt32Enum_.AddEntriesFrom(input, _map_mapInt32Enum_codec); + break; + } + case 138: { + mapInt32ForeignMessage_.AddEntriesFrom(input, _map_mapInt32ForeignMessage_codec); + break; + } + } + } + } + + #region Nested types + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class Types { + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32Int32Entry : pb::IMessage<MapInt32Int32Entry> { + private static readonly pb::MessageParser<MapInt32Int32Entry> _parser = new pb::MessageParser<MapInt32Int32Entry>(() => new MapInt32Int32Entry()); + public static pb::MessageParser<MapInt32Int32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32Int32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32Int32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32Int32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32Int32Entry() { } + + public MapInt32Int32Entry(MapInt32Int32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt32Int32Entry Clone() { + return new MapInt32Int32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private int value_; + public int Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32Int32Entry); + } + + public bool Equals(MapInt32Int32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != 0) { + output.WriteRawTag(16); + output.WriteInt32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Value); + } + return size; + } + + public void MergeFrom(MapInt32Int32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 16: { + Value = input.ReadInt32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt64Int64Entry : pb::IMessage<MapInt64Int64Entry> { + private static readonly pb::MessageParser<MapInt64Int64Entry> _parser = new pb::MessageParser<MapInt64Int64Entry>(() => new MapInt64Int64Entry()); + public static pb::MessageParser<MapInt64Int64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt64Int64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt64Int64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt64Int64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt64Int64Entry() { } + + public MapInt64Int64Entry(MapInt64Int64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt64Int64Entry Clone() { + return new MapInt64Int64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private long key_; + public long Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private long value_; + public long Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt64Int64Entry); + } + + public bool Equals(MapInt64Int64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0L) hash ^= Key.GetHashCode(); + if (Value != 0L) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0L) { + output.WriteRawTag(8); + output.WriteInt64(Key); + } + if (Value != 0L) { + output.WriteRawTag(16); + output.WriteInt64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Key); + } + if (Value != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Value); + } + return size; + } + + public void MergeFrom(MapInt64Int64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0L) { + Key = other.Key; + } + if (other.Value != 0L) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt64(); + break; + } + case 16: { + Value = input.ReadInt64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapUint32Uint32Entry : pb::IMessage<MapUint32Uint32Entry> { + private static readonly pb::MessageParser<MapUint32Uint32Entry> _parser = new pb::MessageParser<MapUint32Uint32Entry>(() => new MapUint32Uint32Entry()); + public static pb::MessageParser<MapUint32Uint32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapUint32Uint32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapUint32Uint32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapUint32Uint32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapUint32Uint32Entry() { } + + public MapUint32Uint32Entry(MapUint32Uint32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapUint32Uint32Entry Clone() { + return new MapUint32Uint32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private uint key_; + public uint Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private uint value_; + public uint Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapUint32Uint32Entry); + } + + public bool Equals(MapUint32Uint32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteUInt32(Key); + } + if (Value != 0) { + output.WriteRawTag(16); + output.WriteUInt32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Key); + } + if (Value != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Value); + } + return size; + } + + public void MergeFrom(MapUint32Uint32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadUInt32(); + break; + } + case 16: { + Value = input.ReadUInt32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapUint64Uint64Entry : pb::IMessage<MapUint64Uint64Entry> { + private static readonly pb::MessageParser<MapUint64Uint64Entry> _parser = new pb::MessageParser<MapUint64Uint64Entry>(() => new MapUint64Uint64Entry()); + public static pb::MessageParser<MapUint64Uint64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapUint64Uint64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapUint64Uint64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapUint64Uint64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapUint64Uint64Entry() { } + + public MapUint64Uint64Entry(MapUint64Uint64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapUint64Uint64Entry Clone() { + return new MapUint64Uint64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private ulong key_; + public ulong Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private ulong value_; + public ulong Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapUint64Uint64Entry); + } + + public bool Equals(MapUint64Uint64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0UL) hash ^= Key.GetHashCode(); + if (Value != 0UL) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0UL) { + output.WriteRawTag(8); + output.WriteUInt64(Key); + } + if (Value != 0UL) { + output.WriteRawTag(16); + output.WriteUInt64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0UL) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Key); + } + if (Value != 0UL) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Value); + } + return size; + } + + public void MergeFrom(MapUint64Uint64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0UL) { + Key = other.Key; + } + if (other.Value != 0UL) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadUInt64(); + break; + } + case 16: { + Value = input.ReadUInt64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapSint32Sint32Entry : pb::IMessage<MapSint32Sint32Entry> { + private static readonly pb::MessageParser<MapSint32Sint32Entry> _parser = new pb::MessageParser<MapSint32Sint32Entry>(() => new MapSint32Sint32Entry()); + public static pb::MessageParser<MapSint32Sint32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapSint32Sint32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapSint32Sint32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapSint32Sint32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapSint32Sint32Entry() { } + + public MapSint32Sint32Entry(MapSint32Sint32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapSint32Sint32Entry Clone() { + return new MapSint32Sint32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private int value_; + public int Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapSint32Sint32Entry); + } + + public bool Equals(MapSint32Sint32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteSInt32(Key); + } + if (Value != 0) { + output.WriteRawTag(16); + output.WriteSInt32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeSInt32Size(Key); + } + if (Value != 0) { + size += 1 + pb::CodedOutputStream.ComputeSInt32Size(Value); + } + return size; + } + + public void MergeFrom(MapSint32Sint32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadSInt32(); + break; + } + case 16: { + Value = input.ReadSInt32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapSint64Sint64Entry : pb::IMessage<MapSint64Sint64Entry> { + private static readonly pb::MessageParser<MapSint64Sint64Entry> _parser = new pb::MessageParser<MapSint64Sint64Entry>(() => new MapSint64Sint64Entry()); + public static pb::MessageParser<MapSint64Sint64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapSint64Sint64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapSint64Sint64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapSint64Sint64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapSint64Sint64Entry() { } + + public MapSint64Sint64Entry(MapSint64Sint64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapSint64Sint64Entry Clone() { + return new MapSint64Sint64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private long key_; + public long Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private long value_; + public long Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapSint64Sint64Entry); + } + + public bool Equals(MapSint64Sint64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0L) hash ^= Key.GetHashCode(); + if (Value != 0L) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0L) { + output.WriteRawTag(8); + output.WriteSInt64(Key); + } + if (Value != 0L) { + output.WriteRawTag(16); + output.WriteSInt64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0L) { + size += 1 + pb::CodedOutputStream.ComputeSInt64Size(Key); + } + if (Value != 0L) { + size += 1 + pb::CodedOutputStream.ComputeSInt64Size(Value); + } + return size; + } + + public void MergeFrom(MapSint64Sint64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0L) { + Key = other.Key; + } + if (other.Value != 0L) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadSInt64(); + break; + } + case 16: { + Value = input.ReadSInt64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapFixed32Fixed32Entry : pb::IMessage<MapFixed32Fixed32Entry> { + private static readonly pb::MessageParser<MapFixed32Fixed32Entry> _parser = new pb::MessageParser<MapFixed32Fixed32Entry>(() => new MapFixed32Fixed32Entry()); + public static pb::MessageParser<MapFixed32Fixed32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 13, 21 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapFixed32Fixed32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapFixed32Fixed32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapFixed32Fixed32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapFixed32Fixed32Entry() { } + + public MapFixed32Fixed32Entry(MapFixed32Fixed32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapFixed32Fixed32Entry Clone() { + return new MapFixed32Fixed32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private uint key_; + public uint Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private uint value_; + public uint Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapFixed32Fixed32Entry); + } + + public bool Equals(MapFixed32Fixed32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(13); + output.WriteFixed32(Key); + } + if (Value != 0) { + output.WriteRawTag(21); + output.WriteFixed32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + 4; + } + if (Value != 0) { + size += 1 + 4; + } + return size; + } + + public void MergeFrom(MapFixed32Fixed32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 13: { + Key = input.ReadFixed32(); + break; + } + case 21: { + Value = input.ReadFixed32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapFixed64Fixed64Entry : pb::IMessage<MapFixed64Fixed64Entry> { + private static readonly pb::MessageParser<MapFixed64Fixed64Entry> _parser = new pb::MessageParser<MapFixed64Fixed64Entry>(() => new MapFixed64Fixed64Entry()); + public static pb::MessageParser<MapFixed64Fixed64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 9, 17 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapFixed64Fixed64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapFixed64Fixed64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapFixed64Fixed64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapFixed64Fixed64Entry() { } + + public MapFixed64Fixed64Entry(MapFixed64Fixed64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapFixed64Fixed64Entry Clone() { + return new MapFixed64Fixed64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private ulong key_; + public ulong Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private ulong value_; + public ulong Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapFixed64Fixed64Entry); + } + + public bool Equals(MapFixed64Fixed64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0UL) hash ^= Key.GetHashCode(); + if (Value != 0UL) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0UL) { + output.WriteRawTag(9); + output.WriteFixed64(Key); + } + if (Value != 0UL) { + output.WriteRawTag(17); + output.WriteFixed64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0UL) { + size += 1 + 8; + } + if (Value != 0UL) { + size += 1 + 8; + } + return size; + } + + public void MergeFrom(MapFixed64Fixed64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0UL) { + Key = other.Key; + } + if (other.Value != 0UL) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 9: { + Key = input.ReadFixed64(); + break; + } + case 17: { + Value = input.ReadFixed64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapSfixed32Sfixed32Entry : pb::IMessage<MapSfixed32Sfixed32Entry> { + private static readonly pb::MessageParser<MapSfixed32Sfixed32Entry> _parser = new pb::MessageParser<MapSfixed32Sfixed32Entry>(() => new MapSfixed32Sfixed32Entry()); + public static pb::MessageParser<MapSfixed32Sfixed32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 13, 21 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapSfixed32Sfixed32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapSfixed32Sfixed32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapSfixed32Sfixed32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapSfixed32Sfixed32Entry() { } + + public MapSfixed32Sfixed32Entry(MapSfixed32Sfixed32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapSfixed32Sfixed32Entry Clone() { + return new MapSfixed32Sfixed32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private int value_; + public int Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapSfixed32Sfixed32Entry); + } + + public bool Equals(MapSfixed32Sfixed32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(13); + output.WriteSFixed32(Key); + } + if (Value != 0) { + output.WriteRawTag(21); + output.WriteSFixed32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + 4; + } + if (Value != 0) { + size += 1 + 4; + } + return size; + } + + public void MergeFrom(MapSfixed32Sfixed32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 13: { + Key = input.ReadSFixed32(); + break; + } + case 21: { + Value = input.ReadSFixed32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapSfixed64Sfixed64Entry : pb::IMessage<MapSfixed64Sfixed64Entry> { + private static readonly pb::MessageParser<MapSfixed64Sfixed64Entry> _parser = new pb::MessageParser<MapSfixed64Sfixed64Entry>(() => new MapSfixed64Sfixed64Entry()); + public static pb::MessageParser<MapSfixed64Sfixed64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 9, 17 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapSfixed64Sfixed64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapSfixed64Sfixed64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapSfixed64Sfixed64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapSfixed64Sfixed64Entry() { } + + public MapSfixed64Sfixed64Entry(MapSfixed64Sfixed64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapSfixed64Sfixed64Entry Clone() { + return new MapSfixed64Sfixed64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private long key_; + public long Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private long value_; + public long Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapSfixed64Sfixed64Entry); + } + + public bool Equals(MapSfixed64Sfixed64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0L) hash ^= Key.GetHashCode(); + if (Value != 0L) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0L) { + output.WriteRawTag(9); + output.WriteSFixed64(Key); + } + if (Value != 0L) { + output.WriteRawTag(17); + output.WriteSFixed64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0L) { + size += 1 + 8; + } + if (Value != 0L) { + size += 1 + 8; + } + return size; + } + + public void MergeFrom(MapSfixed64Sfixed64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0L) { + Key = other.Key; + } + if (other.Value != 0L) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 9: { + Key = input.ReadSFixed64(); + break; + } + case 17: { + Value = input.ReadSFixed64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32FloatEntry : pb::IMessage<MapInt32FloatEntry> { + private static readonly pb::MessageParser<MapInt32FloatEntry> _parser = new pb::MessageParser<MapInt32FloatEntry>(() => new MapInt32FloatEntry()); + public static pb::MessageParser<MapInt32FloatEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 21 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32FloatEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32FloatEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32FloatEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32FloatEntry() { } + + public MapInt32FloatEntry(MapInt32FloatEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt32FloatEntry Clone() { + return new MapInt32FloatEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private float value_; + public float Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32FloatEntry); + } + + public bool Equals(MapInt32FloatEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0F) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != 0F) { + output.WriteRawTag(21); + output.WriteFloat(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != 0F) { + size += 1 + 4; + } + return size; + } + + public void MergeFrom(MapInt32FloatEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0F) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 21: { + Value = input.ReadFloat(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32DoubleEntry : pb::IMessage<MapInt32DoubleEntry> { + private static readonly pb::MessageParser<MapInt32DoubleEntry> _parser = new pb::MessageParser<MapInt32DoubleEntry>(() => new MapInt32DoubleEntry()); + public static pb::MessageParser<MapInt32DoubleEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 17 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32DoubleEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32DoubleEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32DoubleEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32DoubleEntry() { } + + public MapInt32DoubleEntry(MapInt32DoubleEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt32DoubleEntry Clone() { + return new MapInt32DoubleEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private double value_; + public double Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32DoubleEntry); + } + + public bool Equals(MapInt32DoubleEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0D) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != 0D) { + output.WriteRawTag(17); + output.WriteDouble(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != 0D) { + size += 1 + 8; + } + return size; + } + + public void MergeFrom(MapInt32DoubleEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0D) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 17: { + Value = input.ReadDouble(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapBoolBoolEntry : pb::IMessage<MapBoolBoolEntry> { + private static readonly pb::MessageParser<MapBoolBoolEntry> _parser = new pb::MessageParser<MapBoolBoolEntry>(() => new MapBoolBoolEntry()); + public static pb::MessageParser<MapBoolBoolEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapBoolBoolEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapBoolBoolEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapBoolBoolEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapBoolBoolEntry() { } + + public MapBoolBoolEntry(MapBoolBoolEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapBoolBoolEntry Clone() { + return new MapBoolBoolEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private bool key_; + public bool Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private bool value_; + public bool Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapBoolBoolEntry); + } + + public bool Equals(MapBoolBoolEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != false) hash ^= Key.GetHashCode(); + if (Value != false) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != false) { + output.WriteRawTag(8); + output.WriteBool(Key); + } + if (Value != false) { + output.WriteRawTag(16); + output.WriteBool(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != false) { + size += 1 + 1; + } + if (Value != false) { + size += 1 + 1; + } + return size; + } + + public void MergeFrom(MapBoolBoolEntry other) { + if (other == null) { + return; + } + if (other.Key != false) { + Key = other.Key; + } + if (other.Value != false) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadBool(); + break; + } + case 16: { + Value = input.ReadBool(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapStringStringEntry : pb::IMessage<MapStringStringEntry> { + private static readonly pb::MessageParser<MapStringStringEntry> _parser = new pb::MessageParser<MapStringStringEntry>(() => new MapStringStringEntry()); + public static pb::MessageParser<MapStringStringEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 10, 18 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapStringStringEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapStringStringEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapStringStringEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapStringStringEntry() { } + + public MapStringStringEntry(MapStringStringEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapStringStringEntry Clone() { + return new MapStringStringEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private string key_ = ""; + public string Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value ?? ""; + } + } + + public const int ValueFieldNumber = 2; + private string value_ = ""; + public string Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value ?? ""; + } + } + + public override bool Equals(object other) { + return Equals(other as MapStringStringEntry); + } + + public bool Equals(MapStringStringEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key.Length != 0) hash ^= Key.GetHashCode(); + if (Value.Length != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key.Length != 0) { + output.WriteRawTag(10); + output.WriteString(Key); + } + if (Value.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Key); + } + if (Value.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Value); + } + return size; + } + + public void MergeFrom(MapStringStringEntry other) { + if (other == null) { + return; + } + if (other.Key.Length != 0) { + Key = other.Key; + } + if (other.Value.Length != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 10: { + Key = input.ReadString(); + break; + } + case 18: { + Value = input.ReadString(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32BytesEntry : pb::IMessage<MapInt32BytesEntry> { + private static readonly pb::MessageParser<MapInt32BytesEntry> _parser = new pb::MessageParser<MapInt32BytesEntry>(() => new MapInt32BytesEntry()); + public static pb::MessageParser<MapInt32BytesEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 18 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32BytesEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32BytesEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32BytesEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32BytesEntry() { } + + public MapInt32BytesEntry(MapInt32BytesEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt32BytesEntry Clone() { + return new MapInt32BytesEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private pb::ByteString value_ = pb::ByteString.Empty; + public pb::ByteString Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value ?? pb::ByteString.Empty; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32BytesEntry); + } + + public bool Equals(MapInt32BytesEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value.Length != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value.Length != 0) { + output.WriteRawTag(18); + output.WriteBytes(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(Value); + } + return size; + } + + public void MergeFrom(MapInt32BytesEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value.Length != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 18: { + Value = input.ReadBytes(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32EnumEntry : pb::IMessage<MapInt32EnumEntry> { + private static readonly pb::MessageParser<MapInt32EnumEntry> _parser = new pb::MessageParser<MapInt32EnumEntry>(() => new MapInt32EnumEntry()); + public static pb::MessageParser<MapInt32EnumEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32EnumEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32EnumEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32EnumEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32EnumEntry() { } + + public MapInt32EnumEntry(MapInt32EnumEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt32EnumEntry Clone() { + return new MapInt32EnumEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private global::Google.Protobuf.TestProtos.MapEnum value_ = global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO; + public global::Google.Protobuf.TestProtos.MapEnum Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32EnumEntry); + } + + public bool Equals(MapInt32EnumEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO) { + output.WriteRawTag(16); + output.WriteEnum((int) Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Value); + } + return size; + } + + public void MergeFrom(MapInt32EnumEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 16: { + value_ = (global::Google.Protobuf.TestProtos.MapEnum) input.ReadEnum(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32ForeignMessageEntry : pb::IMessage<MapInt32ForeignMessageEntry> { + private static readonly pb::MessageParser<MapInt32ForeignMessageEntry> _parser = new pb::MessageParser<MapInt32ForeignMessageEntry>(() => new MapInt32ForeignMessageEntry()); + public static pb::MessageParser<MapInt32ForeignMessageEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 18 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32ForeignMessageEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32ForeignMessageEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMap_MapInt32ForeignMessageEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32ForeignMessageEntry() { } + + public MapInt32ForeignMessageEntry(MapInt32ForeignMessageEntry other) { + key_ = other.key_; + Value = other.value_ != null ? other.Value.Clone() : null; + } + + public MapInt32ForeignMessageEntry Clone() { + return new MapInt32ForeignMessageEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + if (value_ != null) Value.Freeze(); + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private global::Google.Protobuf.TestProtos.ForeignMessage value_; + public global::Google.Protobuf.TestProtos.ForeignMessage Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32ForeignMessageEntry); + } + + public bool Equals(MapInt32ForeignMessageEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (!object.Equals(Value, other.Value)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (value_ != null) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (value_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (value_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value); + } + return size; + } + + public void MergeFrom(MapInt32ForeignMessageEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.value_ != null) { + if (value_ == null) { + value_ = new global::Google.Protobuf.TestProtos.ForeignMessage(); + } + Value.MergeFrom(other.Value); + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 18: { + if (value_ == null) { + value_ = new global::Google.Protobuf.TestProtos.ForeignMessage(); + } + input.ReadMessage(value_); + break; + } + } + } + } + + } + + } + #endregion + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class TestMapSubmessage : pb::IMessage<TestMapSubmessage> { + private static readonly pb::MessageParser<TestMapSubmessage> _parser = new pb::MessageParser<TestMapSubmessage>(() => new TestMapSubmessage()); + public static pb::MessageParser<TestMapSubmessage> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "test_map" }; + private static readonly uint[] _fieldTags = new uint[] { 10 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMapSubmessage__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<TestMapSubmessage> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMapSubmessage__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public TestMapSubmessage() { } + + public TestMapSubmessage(TestMapSubmessage other) { + TestMap = other.testMap_ != null ? other.TestMap.Clone() : null; + } + + public TestMapSubmessage Clone() { + return new TestMapSubmessage(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + if (testMap_ != null) TestMap.Freeze(); + } + + public const int TestMapFieldNumber = 1; + private global::Google.Protobuf.TestProtos.TestMap testMap_; + public global::Google.Protobuf.TestProtos.TestMap TestMap { + get { return testMap_; } + set { + pb::Freezable.CheckMutable(this); + testMap_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as TestMapSubmessage); + } + + public bool Equals(TestMapSubmessage other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(TestMap, other.TestMap)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (testMap_ != null) hash ^= TestMap.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (testMap_ != null) { + output.WriteRawTag(10); + output.WriteMessage(TestMap); + } + } + + public int CalculateSize() { + int size = 0; + if (testMap_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(TestMap); + } + return size; + } + + public void MergeFrom(TestMapSubmessage other) { + if (other == null) { + return; + } + if (other.testMap_ != null) { + if (testMap_ == null) { + testMap_ = new global::Google.Protobuf.TestProtos.TestMap(); + } + TestMap.MergeFrom(other.TestMap); + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 10: { + if (testMap_ == null) { + testMap_ = new global::Google.Protobuf.TestProtos.TestMap(); + } + input.ReadMessage(testMap_); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class TestMessageMap : pb::IMessage<TestMessageMap> { + private static readonly pb::MessageParser<TestMessageMap> _parser = new pb::MessageParser<TestMessageMap>(() => new TestMessageMap()); + public static pb::MessageParser<TestMessageMap> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "map_int32_message" }; + private static readonly uint[] _fieldTags = new uint[] { 10 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMessageMap__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<TestMessageMap> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMessageMap__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public TestMessageMap() { } + + public TestMessageMap(TestMessageMap other) { + mapInt32Message_ = other.mapInt32Message_.Clone(); + } + + public TestMessageMap Clone() { + return new TestMessageMap(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + mapInt32Message_.Freeze(); + } + + public const int MapInt32MessageFieldNumber = 1; + private static readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.TestAllTypes>.Codec _map_mapInt32Message_codec + = new pbc::MapField<int, global::Google.Protobuf.TestProtos.TestAllTypes>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.TestProtos.TestAllTypes.Parser), 10); + private readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.TestAllTypes> mapInt32Message_ = new pbc::MapField<int, global::Google.Protobuf.TestProtos.TestAllTypes>(); + public pbc::MapField<int, global::Google.Protobuf.TestProtos.TestAllTypes> MapInt32Message { + get { return mapInt32Message_; } + } + + public override bool Equals(object other) { + return Equals(other as TestMessageMap); + } + + public bool Equals(TestMessageMap other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!MapInt32Message.Equals(other.MapInt32Message)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + hash ^= MapInt32Message.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + mapInt32Message_.WriteTo(output, _map_mapInt32Message_codec); + } + + public int CalculateSize() { + int size = 0; + size += mapInt32Message_.CalculateSize(_map_mapInt32Message_codec); + return size; + } + + public void MergeFrom(TestMessageMap other) { + if (other == null) { + return; + } + mapInt32Message_.Add(other.mapInt32Message_); + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 10: { + mapInt32Message_.AddEntriesFrom(input, _map_mapInt32Message_codec); + break; + } + } + } + } + + #region Nested types + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class Types { + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32MessageEntry : pb::IMessage<MapInt32MessageEntry> { + private static readonly pb::MessageParser<MapInt32MessageEntry> _parser = new pb::MessageParser<MapInt32MessageEntry>(() => new MapInt32MessageEntry()); + public static pb::MessageParser<MapInt32MessageEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 18 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMessageMap_MapInt32MessageEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32MessageEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestMessageMap_MapInt32MessageEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32MessageEntry() { } + + public MapInt32MessageEntry(MapInt32MessageEntry other) { + key_ = other.key_; + Value = other.value_ != null ? other.Value.Clone() : null; + } + + public MapInt32MessageEntry Clone() { + return new MapInt32MessageEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + if (value_ != null) Value.Freeze(); + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private global::Google.Protobuf.TestProtos.TestAllTypes value_; + public global::Google.Protobuf.TestProtos.TestAllTypes Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32MessageEntry); + } + + public bool Equals(MapInt32MessageEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (!object.Equals(Value, other.Value)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (value_ != null) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (value_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (value_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value); + } + return size; + } + + public void MergeFrom(MapInt32MessageEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.value_ != null) { + if (value_ == null) { + value_ = new global::Google.Protobuf.TestProtos.TestAllTypes(); + } + Value.MergeFrom(other.Value); + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 18: { + if (value_ == null) { + value_ = new global::Google.Protobuf.TestProtos.TestAllTypes(); + } + input.ReadMessage(value_); + break; + } + } + } + } + + } + + } + #endregion + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class TestSameTypeMap : pb::IMessage<TestSameTypeMap> { + private static readonly pb::MessageParser<TestSameTypeMap> _parser = new pb::MessageParser<TestSameTypeMap>(() => new TestSameTypeMap()); + public static pb::MessageParser<TestSameTypeMap> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "map1", "map2" }; + private static readonly uint[] _fieldTags = new uint[] { 10, 18 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestSameTypeMap__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<TestSameTypeMap> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestSameTypeMap__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public TestSameTypeMap() { } + + public TestSameTypeMap(TestSameTypeMap other) { + map1_ = other.map1_.Clone(); + map2_ = other.map2_.Clone(); + } + + public TestSameTypeMap Clone() { + return new TestSameTypeMap(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + map1_.Freeze(); + map2_.Freeze(); + } + + public const int Map1FieldNumber = 1; + private static readonly pbc::MapField<int, int>.Codec _map_map1_codec + = new pbc::MapField<int, int>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForInt32(16), 10); + private readonly pbc::MapField<int, int> map1_ = new pbc::MapField<int, int>(); + public pbc::MapField<int, int> Map1 { + get { return map1_; } + } + + public const int Map2FieldNumber = 2; + private static readonly pbc::MapField<int, int>.Codec _map_map2_codec + = new pbc::MapField<int, int>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForInt32(16), 18); + private readonly pbc::MapField<int, int> map2_ = new pbc::MapField<int, int>(); + public pbc::MapField<int, int> Map2 { + get { return map2_; } + } + + public override bool Equals(object other) { + return Equals(other as TestSameTypeMap); + } + + public bool Equals(TestSameTypeMap other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!Map1.Equals(other.Map1)) return false; + if (!Map2.Equals(other.Map2)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + hash ^= Map1.GetHashCode(); + hash ^= Map2.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + map1_.WriteTo(output, _map_map1_codec); + map2_.WriteTo(output, _map_map2_codec); + } + + public int CalculateSize() { + int size = 0; + size += map1_.CalculateSize(_map_map1_codec); + size += map2_.CalculateSize(_map_map2_codec); + return size; + } + + public void MergeFrom(TestSameTypeMap other) { + if (other == null) { + return; + } + map1_.Add(other.map1_); + map2_.Add(other.map2_); + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 10: { + map1_.AddEntriesFrom(input, _map_map1_codec); + break; + } + case 18: { + map2_.AddEntriesFrom(input, _map_map2_codec); + break; + } + } + } + } + + #region Nested types + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class Types { + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Map1Entry : pb::IMessage<Map1Entry> { + private static readonly pb::MessageParser<Map1Entry> _parser = new pb::MessageParser<Map1Entry>(() => new Map1Entry()); + public static pb::MessageParser<Map1Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestSameTypeMap_Map1Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<Map1Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestSameTypeMap_Map1Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public Map1Entry() { } + + public Map1Entry(Map1Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public Map1Entry Clone() { + return new Map1Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private int value_; + public int Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as Map1Entry); + } + + public bool Equals(Map1Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != 0) { + output.WriteRawTag(16); + output.WriteInt32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Value); + } + return size; + } + + public void MergeFrom(Map1Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 16: { + Value = input.ReadInt32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class Map2Entry : pb::IMessage<Map2Entry> { + private static readonly pb::MessageParser<Map2Entry> _parser = new pb::MessageParser<Map2Entry>(() => new Map2Entry()); + public static pb::MessageParser<Map2Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestSameTypeMap_Map2Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<Map2Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestSameTypeMap_Map2Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public Map2Entry() { } + + public Map2Entry(Map2Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public Map2Entry Clone() { + return new Map2Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private int value_; + public int Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as Map2Entry); + } + + public bool Equals(Map2Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != 0) { + output.WriteRawTag(16); + output.WriteInt32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Value); + } + return size; + } + + public void MergeFrom(Map2Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 16: { + Value = input.ReadInt32(); + break; + } + } + } + } + + } + + } + #endregion + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class TestArenaMap : pb::IMessage<TestArenaMap> { + private static readonly pb::MessageParser<TestArenaMap> _parser = new pb::MessageParser<TestArenaMap>(() => new TestArenaMap()); + public static pb::MessageParser<TestArenaMap> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "map_bool_bool", "map_fixed32_fixed32", "map_fixed64_fixed64", "map_int32_double", "map_int32_enum", "map_int32_float", "map_int32_foreign_message", "map_int32_int32", "map_int64_int64", "map_sfixed32_sfixed32", "map_sfixed64_sfixed64", "map_sint32_sint32", "map_sint64_sint64", "map_uint32_uint32", "map_uint64_uint64" }; + private static readonly uint[] _fieldTags = new uint[] { 106, 58, 66, 98, 114, 90, 122, 10, 18, 74, 82, 42, 50, 26, 34 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<TestArenaMap> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public TestArenaMap() { } + + public TestArenaMap(TestArenaMap other) { + mapInt32Int32_ = other.mapInt32Int32_.Clone(); + mapInt64Int64_ = other.mapInt64Int64_.Clone(); + mapUint32Uint32_ = other.mapUint32Uint32_.Clone(); + mapUint64Uint64_ = other.mapUint64Uint64_.Clone(); + mapSint32Sint32_ = other.mapSint32Sint32_.Clone(); + mapSint64Sint64_ = other.mapSint64Sint64_.Clone(); + mapFixed32Fixed32_ = other.mapFixed32Fixed32_.Clone(); + mapFixed64Fixed64_ = other.mapFixed64Fixed64_.Clone(); + mapSfixed32Sfixed32_ = other.mapSfixed32Sfixed32_.Clone(); + mapSfixed64Sfixed64_ = other.mapSfixed64Sfixed64_.Clone(); + mapInt32Float_ = other.mapInt32Float_.Clone(); + mapInt32Double_ = other.mapInt32Double_.Clone(); + mapBoolBool_ = other.mapBoolBool_.Clone(); + mapInt32Enum_ = other.mapInt32Enum_.Clone(); + mapInt32ForeignMessage_ = other.mapInt32ForeignMessage_.Clone(); + } + + public TestArenaMap Clone() { + return new TestArenaMap(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + mapInt32Int32_.Freeze(); + mapInt64Int64_.Freeze(); + mapUint32Uint32_.Freeze(); + mapUint64Uint64_.Freeze(); + mapSint32Sint32_.Freeze(); + mapSint64Sint64_.Freeze(); + mapFixed32Fixed32_.Freeze(); + mapFixed64Fixed64_.Freeze(); + mapSfixed32Sfixed32_.Freeze(); + mapSfixed64Sfixed64_.Freeze(); + mapInt32Float_.Freeze(); + mapInt32Double_.Freeze(); + mapBoolBool_.Freeze(); + mapInt32Enum_.Freeze(); + mapInt32ForeignMessage_.Freeze(); + } + + public const int MapInt32Int32FieldNumber = 1; + private static readonly pbc::MapField<int, int>.Codec _map_mapInt32Int32_codec + = new pbc::MapField<int, int>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForInt32(16), 10); + private readonly pbc::MapField<int, int> mapInt32Int32_ = new pbc::MapField<int, int>(); + public pbc::MapField<int, int> MapInt32Int32 { + get { return mapInt32Int32_; } + } + + public const int MapInt64Int64FieldNumber = 2; + private static readonly pbc::MapField<long, long>.Codec _map_mapInt64Int64_codec + = new pbc::MapField<long, long>.Codec(pb::FieldCodec.ForInt64(8), pb::FieldCodec.ForInt64(16), 18); + private readonly pbc::MapField<long, long> mapInt64Int64_ = new pbc::MapField<long, long>(); + public pbc::MapField<long, long> MapInt64Int64 { + get { return mapInt64Int64_; } + } + + public const int MapUint32Uint32FieldNumber = 3; + private static readonly pbc::MapField<uint, uint>.Codec _map_mapUint32Uint32_codec + = new pbc::MapField<uint, uint>.Codec(pb::FieldCodec.ForUInt32(8), pb::FieldCodec.ForUInt32(16), 26); + private readonly pbc::MapField<uint, uint> mapUint32Uint32_ = new pbc::MapField<uint, uint>(); + public pbc::MapField<uint, uint> MapUint32Uint32 { + get { return mapUint32Uint32_; } + } + + public const int MapUint64Uint64FieldNumber = 4; + private static readonly pbc::MapField<ulong, ulong>.Codec _map_mapUint64Uint64_codec + = new pbc::MapField<ulong, ulong>.Codec(pb::FieldCodec.ForUInt64(8), pb::FieldCodec.ForUInt64(16), 34); + private readonly pbc::MapField<ulong, ulong> mapUint64Uint64_ = new pbc::MapField<ulong, ulong>(); + public pbc::MapField<ulong, ulong> MapUint64Uint64 { + get { return mapUint64Uint64_; } + } + + public const int MapSint32Sint32FieldNumber = 5; + private static readonly pbc::MapField<int, int>.Codec _map_mapSint32Sint32_codec + = new pbc::MapField<int, int>.Codec(pb::FieldCodec.ForSInt32(8), pb::FieldCodec.ForSInt32(16), 42); + private readonly pbc::MapField<int, int> mapSint32Sint32_ = new pbc::MapField<int, int>(); + public pbc::MapField<int, int> MapSint32Sint32 { + get { return mapSint32Sint32_; } + } + + public const int MapSint64Sint64FieldNumber = 6; + private static readonly pbc::MapField<long, long>.Codec _map_mapSint64Sint64_codec + = new pbc::MapField<long, long>.Codec(pb::FieldCodec.ForSInt64(8), pb::FieldCodec.ForSInt64(16), 50); + private readonly pbc::MapField<long, long> mapSint64Sint64_ = new pbc::MapField<long, long>(); + public pbc::MapField<long, long> MapSint64Sint64 { + get { return mapSint64Sint64_; } + } + + public const int MapFixed32Fixed32FieldNumber = 7; + private static readonly pbc::MapField<uint, uint>.Codec _map_mapFixed32Fixed32_codec + = new pbc::MapField<uint, uint>.Codec(pb::FieldCodec.ForFixed32(13), pb::FieldCodec.ForFixed32(21), 58); + private readonly pbc::MapField<uint, uint> mapFixed32Fixed32_ = new pbc::MapField<uint, uint>(); + public pbc::MapField<uint, uint> MapFixed32Fixed32 { + get { return mapFixed32Fixed32_; } + } + + public const int MapFixed64Fixed64FieldNumber = 8; + private static readonly pbc::MapField<ulong, ulong>.Codec _map_mapFixed64Fixed64_codec + = new pbc::MapField<ulong, ulong>.Codec(pb::FieldCodec.ForFixed64(9), pb::FieldCodec.ForFixed64(17), 66); + private readonly pbc::MapField<ulong, ulong> mapFixed64Fixed64_ = new pbc::MapField<ulong, ulong>(); + public pbc::MapField<ulong, ulong> MapFixed64Fixed64 { + get { return mapFixed64Fixed64_; } + } + + public const int MapSfixed32Sfixed32FieldNumber = 9; + private static readonly pbc::MapField<int, int>.Codec _map_mapSfixed32Sfixed32_codec + = new pbc::MapField<int, int>.Codec(pb::FieldCodec.ForSFixed32(13), pb::FieldCodec.ForSFixed32(21), 74); + private readonly pbc::MapField<int, int> mapSfixed32Sfixed32_ = new pbc::MapField<int, int>(); + public pbc::MapField<int, int> MapSfixed32Sfixed32 { + get { return mapSfixed32Sfixed32_; } + } + + public const int MapSfixed64Sfixed64FieldNumber = 10; + private static readonly pbc::MapField<long, long>.Codec _map_mapSfixed64Sfixed64_codec + = new pbc::MapField<long, long>.Codec(pb::FieldCodec.ForSFixed64(9), pb::FieldCodec.ForSFixed64(17), 82); + private readonly pbc::MapField<long, long> mapSfixed64Sfixed64_ = new pbc::MapField<long, long>(); + public pbc::MapField<long, long> MapSfixed64Sfixed64 { + get { return mapSfixed64Sfixed64_; } + } + + public const int MapInt32FloatFieldNumber = 11; + private static readonly pbc::MapField<int, float>.Codec _map_mapInt32Float_codec + = new pbc::MapField<int, float>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForFloat(21), 90); + private readonly pbc::MapField<int, float> mapInt32Float_ = new pbc::MapField<int, float>(); + public pbc::MapField<int, float> MapInt32Float { + get { return mapInt32Float_; } + } + + public const int MapInt32DoubleFieldNumber = 12; + private static readonly pbc::MapField<int, double>.Codec _map_mapInt32Double_codec + = new pbc::MapField<int, double>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForDouble(17), 98); + private readonly pbc::MapField<int, double> mapInt32Double_ = new pbc::MapField<int, double>(); + public pbc::MapField<int, double> MapInt32Double { + get { return mapInt32Double_; } + } + + public const int MapBoolBoolFieldNumber = 13; + private static readonly pbc::MapField<bool, bool>.Codec _map_mapBoolBool_codec + = new pbc::MapField<bool, bool>.Codec(pb::FieldCodec.ForBool(8), pb::FieldCodec.ForBool(16), 106); + private readonly pbc::MapField<bool, bool> mapBoolBool_ = new pbc::MapField<bool, bool>(); + public pbc::MapField<bool, bool> MapBoolBool { + get { return mapBoolBool_; } + } + + public const int MapInt32EnumFieldNumber = 14; + private static readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum>.Codec _map_mapInt32Enum_codec + = new pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForEnum(16, x => (int) x, x => (global::Google.Protobuf.TestProtos.MapEnum) x), 114); + private readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum> mapInt32Enum_ = new pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum>(); + public pbc::MapField<int, global::Google.Protobuf.TestProtos.MapEnum> MapInt32Enum { + get { return mapInt32Enum_; } + } + + public const int MapInt32ForeignMessageFieldNumber = 15; + private static readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage>.Codec _map_mapInt32ForeignMessage_codec + = new pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.TestProtos.ForeignMessage.Parser), 122); + private readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage> mapInt32ForeignMessage_ = new pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage>(); + public pbc::MapField<int, global::Google.Protobuf.TestProtos.ForeignMessage> MapInt32ForeignMessage { + get { return mapInt32ForeignMessage_; } + } + + public override bool Equals(object other) { + return Equals(other as TestArenaMap); + } + + public bool Equals(TestArenaMap other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!MapInt32Int32.Equals(other.MapInt32Int32)) return false; + if (!MapInt64Int64.Equals(other.MapInt64Int64)) return false; + if (!MapUint32Uint32.Equals(other.MapUint32Uint32)) return false; + if (!MapUint64Uint64.Equals(other.MapUint64Uint64)) return false; + if (!MapSint32Sint32.Equals(other.MapSint32Sint32)) return false; + if (!MapSint64Sint64.Equals(other.MapSint64Sint64)) return false; + if (!MapFixed32Fixed32.Equals(other.MapFixed32Fixed32)) return false; + if (!MapFixed64Fixed64.Equals(other.MapFixed64Fixed64)) return false; + if (!MapSfixed32Sfixed32.Equals(other.MapSfixed32Sfixed32)) return false; + if (!MapSfixed64Sfixed64.Equals(other.MapSfixed64Sfixed64)) return false; + if (!MapInt32Float.Equals(other.MapInt32Float)) return false; + if (!MapInt32Double.Equals(other.MapInt32Double)) return false; + if (!MapBoolBool.Equals(other.MapBoolBool)) return false; + if (!MapInt32Enum.Equals(other.MapInt32Enum)) return false; + if (!MapInt32ForeignMessage.Equals(other.MapInt32ForeignMessage)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + hash ^= MapInt32Int32.GetHashCode(); + hash ^= MapInt64Int64.GetHashCode(); + hash ^= MapUint32Uint32.GetHashCode(); + hash ^= MapUint64Uint64.GetHashCode(); + hash ^= MapSint32Sint32.GetHashCode(); + hash ^= MapSint64Sint64.GetHashCode(); + hash ^= MapFixed32Fixed32.GetHashCode(); + hash ^= MapFixed64Fixed64.GetHashCode(); + hash ^= MapSfixed32Sfixed32.GetHashCode(); + hash ^= MapSfixed64Sfixed64.GetHashCode(); + hash ^= MapInt32Float.GetHashCode(); + hash ^= MapInt32Double.GetHashCode(); + hash ^= MapBoolBool.GetHashCode(); + hash ^= MapInt32Enum.GetHashCode(); + hash ^= MapInt32ForeignMessage.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + mapInt32Int32_.WriteTo(output, _map_mapInt32Int32_codec); + mapInt64Int64_.WriteTo(output, _map_mapInt64Int64_codec); + mapUint32Uint32_.WriteTo(output, _map_mapUint32Uint32_codec); + mapUint64Uint64_.WriteTo(output, _map_mapUint64Uint64_codec); + mapSint32Sint32_.WriteTo(output, _map_mapSint32Sint32_codec); + mapSint64Sint64_.WriteTo(output, _map_mapSint64Sint64_codec); + mapFixed32Fixed32_.WriteTo(output, _map_mapFixed32Fixed32_codec); + mapFixed64Fixed64_.WriteTo(output, _map_mapFixed64Fixed64_codec); + mapSfixed32Sfixed32_.WriteTo(output, _map_mapSfixed32Sfixed32_codec); + mapSfixed64Sfixed64_.WriteTo(output, _map_mapSfixed64Sfixed64_codec); + mapInt32Float_.WriteTo(output, _map_mapInt32Float_codec); + mapInt32Double_.WriteTo(output, _map_mapInt32Double_codec); + mapBoolBool_.WriteTo(output, _map_mapBoolBool_codec); + mapInt32Enum_.WriteTo(output, _map_mapInt32Enum_codec); + mapInt32ForeignMessage_.WriteTo(output, _map_mapInt32ForeignMessage_codec); + } + + public int CalculateSize() { + int size = 0; + size += mapInt32Int32_.CalculateSize(_map_mapInt32Int32_codec); + size += mapInt64Int64_.CalculateSize(_map_mapInt64Int64_codec); + size += mapUint32Uint32_.CalculateSize(_map_mapUint32Uint32_codec); + size += mapUint64Uint64_.CalculateSize(_map_mapUint64Uint64_codec); + size += mapSint32Sint32_.CalculateSize(_map_mapSint32Sint32_codec); + size += mapSint64Sint64_.CalculateSize(_map_mapSint64Sint64_codec); + size += mapFixed32Fixed32_.CalculateSize(_map_mapFixed32Fixed32_codec); + size += mapFixed64Fixed64_.CalculateSize(_map_mapFixed64Fixed64_codec); + size += mapSfixed32Sfixed32_.CalculateSize(_map_mapSfixed32Sfixed32_codec); + size += mapSfixed64Sfixed64_.CalculateSize(_map_mapSfixed64Sfixed64_codec); + size += mapInt32Float_.CalculateSize(_map_mapInt32Float_codec); + size += mapInt32Double_.CalculateSize(_map_mapInt32Double_codec); + size += mapBoolBool_.CalculateSize(_map_mapBoolBool_codec); + size += mapInt32Enum_.CalculateSize(_map_mapInt32Enum_codec); + size += mapInt32ForeignMessage_.CalculateSize(_map_mapInt32ForeignMessage_codec); + return size; + } + + public void MergeFrom(TestArenaMap other) { + if (other == null) { + return; + } + mapInt32Int32_.Add(other.mapInt32Int32_); + mapInt64Int64_.Add(other.mapInt64Int64_); + mapUint32Uint32_.Add(other.mapUint32Uint32_); + mapUint64Uint64_.Add(other.mapUint64Uint64_); + mapSint32Sint32_.Add(other.mapSint32Sint32_); + mapSint64Sint64_.Add(other.mapSint64Sint64_); + mapFixed32Fixed32_.Add(other.mapFixed32Fixed32_); + mapFixed64Fixed64_.Add(other.mapFixed64Fixed64_); + mapSfixed32Sfixed32_.Add(other.mapSfixed32Sfixed32_); + mapSfixed64Sfixed64_.Add(other.mapSfixed64Sfixed64_); + mapInt32Float_.Add(other.mapInt32Float_); + mapInt32Double_.Add(other.mapInt32Double_); + mapBoolBool_.Add(other.mapBoolBool_); + mapInt32Enum_.Add(other.mapInt32Enum_); + mapInt32ForeignMessage_.Add(other.mapInt32ForeignMessage_); + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 10: { + mapInt32Int32_.AddEntriesFrom(input, _map_mapInt32Int32_codec); + break; + } + case 18: { + mapInt64Int64_.AddEntriesFrom(input, _map_mapInt64Int64_codec); + break; + } + case 26: { + mapUint32Uint32_.AddEntriesFrom(input, _map_mapUint32Uint32_codec); + break; + } + case 34: { + mapUint64Uint64_.AddEntriesFrom(input, _map_mapUint64Uint64_codec); + break; + } + case 42: { + mapSint32Sint32_.AddEntriesFrom(input, _map_mapSint32Sint32_codec); + break; + } + case 50: { + mapSint64Sint64_.AddEntriesFrom(input, _map_mapSint64Sint64_codec); + break; + } + case 58: { + mapFixed32Fixed32_.AddEntriesFrom(input, _map_mapFixed32Fixed32_codec); + break; + } + case 66: { + mapFixed64Fixed64_.AddEntriesFrom(input, _map_mapFixed64Fixed64_codec); + break; + } + case 74: { + mapSfixed32Sfixed32_.AddEntriesFrom(input, _map_mapSfixed32Sfixed32_codec); + break; + } + case 82: { + mapSfixed64Sfixed64_.AddEntriesFrom(input, _map_mapSfixed64Sfixed64_codec); + break; + } + case 90: { + mapInt32Float_.AddEntriesFrom(input, _map_mapInt32Float_codec); + break; + } + case 98: { + mapInt32Double_.AddEntriesFrom(input, _map_mapInt32Double_codec); + break; + } + case 106: { + mapBoolBool_.AddEntriesFrom(input, _map_mapBoolBool_codec); + break; + } + case 114: { + mapInt32Enum_.AddEntriesFrom(input, _map_mapInt32Enum_codec); + break; + } + case 122: { + mapInt32ForeignMessage_.AddEntriesFrom(input, _map_mapInt32ForeignMessage_codec); + break; + } + } + } + } + + #region Nested types + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class Types { + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32Int32Entry : pb::IMessage<MapInt32Int32Entry> { + private static readonly pb::MessageParser<MapInt32Int32Entry> _parser = new pb::MessageParser<MapInt32Int32Entry>(() => new MapInt32Int32Entry()); + public static pb::MessageParser<MapInt32Int32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32Int32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32Int32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32Int32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32Int32Entry() { } + + public MapInt32Int32Entry(MapInt32Int32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt32Int32Entry Clone() { + return new MapInt32Int32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private int value_; + public int Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32Int32Entry); + } + + public bool Equals(MapInt32Int32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != 0) { + output.WriteRawTag(16); + output.WriteInt32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Value); + } + return size; + } + + public void MergeFrom(MapInt32Int32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 16: { + Value = input.ReadInt32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt64Int64Entry : pb::IMessage<MapInt64Int64Entry> { + private static readonly pb::MessageParser<MapInt64Int64Entry> _parser = new pb::MessageParser<MapInt64Int64Entry>(() => new MapInt64Int64Entry()); + public static pb::MessageParser<MapInt64Int64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt64Int64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt64Int64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt64Int64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt64Int64Entry() { } + + public MapInt64Int64Entry(MapInt64Int64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt64Int64Entry Clone() { + return new MapInt64Int64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private long key_; + public long Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private long value_; + public long Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt64Int64Entry); + } + + public bool Equals(MapInt64Int64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0L) hash ^= Key.GetHashCode(); + if (Value != 0L) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0L) { + output.WriteRawTag(8); + output.WriteInt64(Key); + } + if (Value != 0L) { + output.WriteRawTag(16); + output.WriteInt64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Key); + } + if (Value != 0L) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Value); + } + return size; + } + + public void MergeFrom(MapInt64Int64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0L) { + Key = other.Key; + } + if (other.Value != 0L) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt64(); + break; + } + case 16: { + Value = input.ReadInt64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapUint32Uint32Entry : pb::IMessage<MapUint32Uint32Entry> { + private static readonly pb::MessageParser<MapUint32Uint32Entry> _parser = new pb::MessageParser<MapUint32Uint32Entry>(() => new MapUint32Uint32Entry()); + public static pb::MessageParser<MapUint32Uint32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapUint32Uint32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapUint32Uint32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapUint32Uint32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapUint32Uint32Entry() { } + + public MapUint32Uint32Entry(MapUint32Uint32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapUint32Uint32Entry Clone() { + return new MapUint32Uint32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private uint key_; + public uint Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private uint value_; + public uint Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapUint32Uint32Entry); + } + + public bool Equals(MapUint32Uint32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteUInt32(Key); + } + if (Value != 0) { + output.WriteRawTag(16); + output.WriteUInt32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Key); + } + if (Value != 0) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Value); + } + return size; + } + + public void MergeFrom(MapUint32Uint32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadUInt32(); + break; + } + case 16: { + Value = input.ReadUInt32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapUint64Uint64Entry : pb::IMessage<MapUint64Uint64Entry> { + private static readonly pb::MessageParser<MapUint64Uint64Entry> _parser = new pb::MessageParser<MapUint64Uint64Entry>(() => new MapUint64Uint64Entry()); + public static pb::MessageParser<MapUint64Uint64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapUint64Uint64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapUint64Uint64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapUint64Uint64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapUint64Uint64Entry() { } + + public MapUint64Uint64Entry(MapUint64Uint64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapUint64Uint64Entry Clone() { + return new MapUint64Uint64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private ulong key_; + public ulong Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private ulong value_; + public ulong Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapUint64Uint64Entry); + } + + public bool Equals(MapUint64Uint64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0UL) hash ^= Key.GetHashCode(); + if (Value != 0UL) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0UL) { + output.WriteRawTag(8); + output.WriteUInt64(Key); + } + if (Value != 0UL) { + output.WriteRawTag(16); + output.WriteUInt64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0UL) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Key); + } + if (Value != 0UL) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Value); + } + return size; + } + + public void MergeFrom(MapUint64Uint64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0UL) { + Key = other.Key; + } + if (other.Value != 0UL) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadUInt64(); + break; + } + case 16: { + Value = input.ReadUInt64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapSint32Sint32Entry : pb::IMessage<MapSint32Sint32Entry> { + private static readonly pb::MessageParser<MapSint32Sint32Entry> _parser = new pb::MessageParser<MapSint32Sint32Entry>(() => new MapSint32Sint32Entry()); + public static pb::MessageParser<MapSint32Sint32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapSint32Sint32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapSint32Sint32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapSint32Sint32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapSint32Sint32Entry() { } + + public MapSint32Sint32Entry(MapSint32Sint32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapSint32Sint32Entry Clone() { + return new MapSint32Sint32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private int value_; + public int Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapSint32Sint32Entry); + } + + public bool Equals(MapSint32Sint32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteSInt32(Key); + } + if (Value != 0) { + output.WriteRawTag(16); + output.WriteSInt32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeSInt32Size(Key); + } + if (Value != 0) { + size += 1 + pb::CodedOutputStream.ComputeSInt32Size(Value); + } + return size; + } + + public void MergeFrom(MapSint32Sint32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadSInt32(); + break; + } + case 16: { + Value = input.ReadSInt32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapSint64Sint64Entry : pb::IMessage<MapSint64Sint64Entry> { + private static readonly pb::MessageParser<MapSint64Sint64Entry> _parser = new pb::MessageParser<MapSint64Sint64Entry>(() => new MapSint64Sint64Entry()); + public static pb::MessageParser<MapSint64Sint64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapSint64Sint64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapSint64Sint64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapSint64Sint64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapSint64Sint64Entry() { } + + public MapSint64Sint64Entry(MapSint64Sint64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapSint64Sint64Entry Clone() { + return new MapSint64Sint64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private long key_; + public long Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private long value_; + public long Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapSint64Sint64Entry); + } + + public bool Equals(MapSint64Sint64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0L) hash ^= Key.GetHashCode(); + if (Value != 0L) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0L) { + output.WriteRawTag(8); + output.WriteSInt64(Key); + } + if (Value != 0L) { + output.WriteRawTag(16); + output.WriteSInt64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0L) { + size += 1 + pb::CodedOutputStream.ComputeSInt64Size(Key); + } + if (Value != 0L) { + size += 1 + pb::CodedOutputStream.ComputeSInt64Size(Value); + } + return size; + } + + public void MergeFrom(MapSint64Sint64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0L) { + Key = other.Key; + } + if (other.Value != 0L) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadSInt64(); + break; + } + case 16: { + Value = input.ReadSInt64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapFixed32Fixed32Entry : pb::IMessage<MapFixed32Fixed32Entry> { + private static readonly pb::MessageParser<MapFixed32Fixed32Entry> _parser = new pb::MessageParser<MapFixed32Fixed32Entry>(() => new MapFixed32Fixed32Entry()); + public static pb::MessageParser<MapFixed32Fixed32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 13, 21 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapFixed32Fixed32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapFixed32Fixed32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapFixed32Fixed32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapFixed32Fixed32Entry() { } + + public MapFixed32Fixed32Entry(MapFixed32Fixed32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapFixed32Fixed32Entry Clone() { + return new MapFixed32Fixed32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private uint key_; + public uint Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private uint value_; + public uint Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapFixed32Fixed32Entry); + } + + public bool Equals(MapFixed32Fixed32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(13); + output.WriteFixed32(Key); + } + if (Value != 0) { + output.WriteRawTag(21); + output.WriteFixed32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + 4; + } + if (Value != 0) { + size += 1 + 4; + } + return size; + } + + public void MergeFrom(MapFixed32Fixed32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 13: { + Key = input.ReadFixed32(); + break; + } + case 21: { + Value = input.ReadFixed32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapFixed64Fixed64Entry : pb::IMessage<MapFixed64Fixed64Entry> { + private static readonly pb::MessageParser<MapFixed64Fixed64Entry> _parser = new pb::MessageParser<MapFixed64Fixed64Entry>(() => new MapFixed64Fixed64Entry()); + public static pb::MessageParser<MapFixed64Fixed64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 9, 17 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapFixed64Fixed64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapFixed64Fixed64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapFixed64Fixed64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapFixed64Fixed64Entry() { } + + public MapFixed64Fixed64Entry(MapFixed64Fixed64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapFixed64Fixed64Entry Clone() { + return new MapFixed64Fixed64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private ulong key_; + public ulong Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private ulong value_; + public ulong Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapFixed64Fixed64Entry); + } + + public bool Equals(MapFixed64Fixed64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0UL) hash ^= Key.GetHashCode(); + if (Value != 0UL) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0UL) { + output.WriteRawTag(9); + output.WriteFixed64(Key); + } + if (Value != 0UL) { + output.WriteRawTag(17); + output.WriteFixed64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0UL) { + size += 1 + 8; + } + if (Value != 0UL) { + size += 1 + 8; + } + return size; + } + + public void MergeFrom(MapFixed64Fixed64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0UL) { + Key = other.Key; + } + if (other.Value != 0UL) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 9: { + Key = input.ReadFixed64(); + break; + } + case 17: { + Value = input.ReadFixed64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapSfixed32Sfixed32Entry : pb::IMessage<MapSfixed32Sfixed32Entry> { + private static readonly pb::MessageParser<MapSfixed32Sfixed32Entry> _parser = new pb::MessageParser<MapSfixed32Sfixed32Entry>(() => new MapSfixed32Sfixed32Entry()); + public static pb::MessageParser<MapSfixed32Sfixed32Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 13, 21 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapSfixed32Sfixed32Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapSfixed32Sfixed32Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapSfixed32Sfixed32Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapSfixed32Sfixed32Entry() { } + + public MapSfixed32Sfixed32Entry(MapSfixed32Sfixed32Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapSfixed32Sfixed32Entry Clone() { + return new MapSfixed32Sfixed32Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private int value_; + public int Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapSfixed32Sfixed32Entry); + } + + public bool Equals(MapSfixed32Sfixed32Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(13); + output.WriteSFixed32(Key); + } + if (Value != 0) { + output.WriteRawTag(21); + output.WriteSFixed32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + 4; + } + if (Value != 0) { + size += 1 + 4; + } + return size; + } + + public void MergeFrom(MapSfixed32Sfixed32Entry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 13: { + Key = input.ReadSFixed32(); + break; + } + case 21: { + Value = input.ReadSFixed32(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapSfixed64Sfixed64Entry : pb::IMessage<MapSfixed64Sfixed64Entry> { + private static readonly pb::MessageParser<MapSfixed64Sfixed64Entry> _parser = new pb::MessageParser<MapSfixed64Sfixed64Entry>(() => new MapSfixed64Sfixed64Entry()); + public static pb::MessageParser<MapSfixed64Sfixed64Entry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 9, 17 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapSfixed64Sfixed64Entry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapSfixed64Sfixed64Entry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapSfixed64Sfixed64Entry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapSfixed64Sfixed64Entry() { } + + public MapSfixed64Sfixed64Entry(MapSfixed64Sfixed64Entry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapSfixed64Sfixed64Entry Clone() { + return new MapSfixed64Sfixed64Entry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private long key_; + public long Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private long value_; + public long Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapSfixed64Sfixed64Entry); + } + + public bool Equals(MapSfixed64Sfixed64Entry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0L) hash ^= Key.GetHashCode(); + if (Value != 0L) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0L) { + output.WriteRawTag(9); + output.WriteSFixed64(Key); + } + if (Value != 0L) { + output.WriteRawTag(17); + output.WriteSFixed64(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0L) { + size += 1 + 8; + } + if (Value != 0L) { + size += 1 + 8; + } + return size; + } + + public void MergeFrom(MapSfixed64Sfixed64Entry other) { + if (other == null) { + return; + } + if (other.Key != 0L) { + Key = other.Key; + } + if (other.Value != 0L) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 9: { + Key = input.ReadSFixed64(); + break; + } + case 17: { + Value = input.ReadSFixed64(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32FloatEntry : pb::IMessage<MapInt32FloatEntry> { + private static readonly pb::MessageParser<MapInt32FloatEntry> _parser = new pb::MessageParser<MapInt32FloatEntry>(() => new MapInt32FloatEntry()); + public static pb::MessageParser<MapInt32FloatEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 21 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32FloatEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32FloatEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32FloatEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32FloatEntry() { } + + public MapInt32FloatEntry(MapInt32FloatEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt32FloatEntry Clone() { + return new MapInt32FloatEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private float value_; + public float Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32FloatEntry); + } + + public bool Equals(MapInt32FloatEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0F) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != 0F) { + output.WriteRawTag(21); + output.WriteFloat(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != 0F) { + size += 1 + 4; + } + return size; + } + + public void MergeFrom(MapInt32FloatEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0F) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 21: { + Value = input.ReadFloat(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32DoubleEntry : pb::IMessage<MapInt32DoubleEntry> { + private static readonly pb::MessageParser<MapInt32DoubleEntry> _parser = new pb::MessageParser<MapInt32DoubleEntry>(() => new MapInt32DoubleEntry()); + public static pb::MessageParser<MapInt32DoubleEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 17 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32DoubleEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32DoubleEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32DoubleEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32DoubleEntry() { } + + public MapInt32DoubleEntry(MapInt32DoubleEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt32DoubleEntry Clone() { + return new MapInt32DoubleEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private double value_; + public double Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32DoubleEntry); + } + + public bool Equals(MapInt32DoubleEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0D) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != 0D) { + output.WriteRawTag(17); + output.WriteDouble(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != 0D) { + size += 1 + 8; + } + return size; + } + + public void MergeFrom(MapInt32DoubleEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0D) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 17: { + Value = input.ReadDouble(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapBoolBoolEntry : pb::IMessage<MapBoolBoolEntry> { + private static readonly pb::MessageParser<MapBoolBoolEntry> _parser = new pb::MessageParser<MapBoolBoolEntry>(() => new MapBoolBoolEntry()); + public static pb::MessageParser<MapBoolBoolEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapBoolBoolEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapBoolBoolEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapBoolBoolEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapBoolBoolEntry() { } + + public MapBoolBoolEntry(MapBoolBoolEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapBoolBoolEntry Clone() { + return new MapBoolBoolEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private bool key_; + public bool Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private bool value_; + public bool Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapBoolBoolEntry); + } + + public bool Equals(MapBoolBoolEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != false) hash ^= Key.GetHashCode(); + if (Value != false) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != false) { + output.WriteRawTag(8); + output.WriteBool(Key); + } + if (Value != false) { + output.WriteRawTag(16); + output.WriteBool(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != false) { + size += 1 + 1; + } + if (Value != false) { + size += 1 + 1; + } + return size; + } + + public void MergeFrom(MapBoolBoolEntry other) { + if (other == null) { + return; + } + if (other.Key != false) { + Key = other.Key; + } + if (other.Value != false) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadBool(); + break; + } + case 16: { + Value = input.ReadBool(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32EnumEntry : pb::IMessage<MapInt32EnumEntry> { + private static readonly pb::MessageParser<MapInt32EnumEntry> _parser = new pb::MessageParser<MapInt32EnumEntry>(() => new MapInt32EnumEntry()); + public static pb::MessageParser<MapInt32EnumEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32EnumEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32EnumEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32EnumEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32EnumEntry() { } + + public MapInt32EnumEntry(MapInt32EnumEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public MapInt32EnumEntry Clone() { + return new MapInt32EnumEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private global::Google.Protobuf.TestProtos.MapEnum value_ = global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO; + public global::Google.Protobuf.TestProtos.MapEnum Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32EnumEntry); + } + + public bool Equals(MapInt32EnumEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO) { + output.WriteRawTag(16); + output.WriteEnum((int) Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Value); + } + return size; + } + + public void MergeFrom(MapInt32EnumEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != global::Google.Protobuf.TestProtos.MapEnum.MAP_ENUM_FOO) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 16: { + value_ = (global::Google.Protobuf.TestProtos.MapEnum) input.ReadEnum(); + break; + } + } + } + } + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MapInt32ForeignMessageEntry : pb::IMessage<MapInt32ForeignMessageEntry> { + private static readonly pb::MessageParser<MapInt32ForeignMessageEntry> _parser = new pb::MessageParser<MapInt32ForeignMessageEntry>(() => new MapInt32ForeignMessageEntry()); + public static pb::MessageParser<MapInt32ForeignMessageEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 18 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32ForeignMessageEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MapInt32ForeignMessageEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_TestArenaMap_MapInt32ForeignMessageEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MapInt32ForeignMessageEntry() { } + + public MapInt32ForeignMessageEntry(MapInt32ForeignMessageEntry other) { + key_ = other.key_; + Value = other.value_ != null ? other.Value.Clone() : null; + } + + public MapInt32ForeignMessageEntry Clone() { + return new MapInt32ForeignMessageEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + if (value_ != null) Value.Freeze(); + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private global::Google.Protobuf.TestProtos.ForeignMessage value_; + public global::Google.Protobuf.TestProtos.ForeignMessage Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as MapInt32ForeignMessageEntry); + } + + public bool Equals(MapInt32ForeignMessageEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (!object.Equals(Value, other.Value)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (value_ != null) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (value_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (value_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value); + } + return size; + } + + public void MergeFrom(MapInt32ForeignMessageEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.value_ != null) { + if (value_ == null) { + value_ = new global::Google.Protobuf.TestProtos.ForeignMessage(); + } + Value.MergeFrom(other.Value); + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 18: { + if (value_ == null) { + value_ = new global::Google.Protobuf.TestProtos.ForeignMessage(); + } + input.ReadMessage(value_); + break; + } + } + } + } + + } + + } + #endregion + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MessageContainingEnumCalledType : pb::IMessage<MessageContainingEnumCalledType> { + private static readonly pb::MessageParser<MessageContainingEnumCalledType> _parser = new pb::MessageParser<MessageContainingEnumCalledType>(() => new MessageContainingEnumCalledType()); + public static pb::MessageParser<MessageContainingEnumCalledType> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "type" }; + private static readonly uint[] _fieldTags = new uint[] { 10 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_MessageContainingEnumCalledType__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MessageContainingEnumCalledType> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_MessageContainingEnumCalledType__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MessageContainingEnumCalledType() { } + + public MessageContainingEnumCalledType(MessageContainingEnumCalledType other) { + type_ = other.type_.Clone(); + } + + public MessageContainingEnumCalledType Clone() { + return new MessageContainingEnumCalledType(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + type_.Freeze(); + } + + public const int TypeFieldNumber = 1; + private static readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType>.Codec _map_type_codec + = new pbc::MapField<int, global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType.Parser), 10); + private readonly pbc::MapField<int, global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType> type_ = new pbc::MapField<int, global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType>(); + public pbc::MapField<int, global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType> Type { + get { return type_; } + } + + public override bool Equals(object other) { + return Equals(other as MessageContainingEnumCalledType); + } + + public bool Equals(MessageContainingEnumCalledType other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!Type.Equals(other.Type)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + hash ^= Type.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + type_.WriteTo(output, _map_type_codec); + } + + public int CalculateSize() { + int size = 0; + size += type_.CalculateSize(_map_type_codec); + return size; + } + + public void MergeFrom(MessageContainingEnumCalledType other) { + if (other == null) { + return; + } + type_.Add(other.type_); + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 10: { + type_.AddEntriesFrom(input, _map_type_codec); + break; + } + } + } + } + + #region Nested types + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class Types { + public enum Type { + TYPE_FOO = 0, + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class TypeEntry : pb::IMessage<TypeEntry> { + private static readonly pb::MessageParser<TypeEntry> _parser = new pb::MessageParser<TypeEntry>(() => new TypeEntry()); + public static pb::MessageParser<TypeEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 18 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_MessageContainingEnumCalledType_TypeEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<TypeEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_MessageContainingEnumCalledType_TypeEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public TypeEntry() { } + + public TypeEntry(TypeEntry other) { + key_ = other.key_; + Value = other.value_ != null ? other.Value.Clone() : null; + } + + public TypeEntry Clone() { + return new TypeEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + if (value_ != null) Value.Freeze(); + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType value_; + public global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as TypeEntry); + } + + public bool Equals(TypeEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (!object.Equals(Value, other.Value)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (value_ != null) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (value_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (value_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value); + } + return size; + } + + public void MergeFrom(TypeEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.value_ != null) { + if (value_ == null) { + value_ = new global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType(); + } + Value.MergeFrom(other.Value); + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 18: { + if (value_ == null) { + value_ = new global::Google.Protobuf.TestProtos.MessageContainingEnumCalledType(); + } + input.ReadMessage(value_); + break; + } + } + } + } + + } + + } + #endregion + + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class MessageContainingMapCalledEntry : pb::IMessage<MessageContainingMapCalledEntry> { + private static readonly pb::MessageParser<MessageContainingMapCalledEntry> _parser = new pb::MessageParser<MessageContainingMapCalledEntry>(() => new MessageContainingMapCalledEntry()); + public static pb::MessageParser<MessageContainingMapCalledEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "entry" }; + private static readonly uint[] _fieldTags = new uint[] { 10 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_MessageContainingMapCalledEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<MessageContainingMapCalledEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_MessageContainingMapCalledEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public MessageContainingMapCalledEntry() { } + + public MessageContainingMapCalledEntry(MessageContainingMapCalledEntry other) { + entry_ = other.entry_.Clone(); + } + + public MessageContainingMapCalledEntry Clone() { + return new MessageContainingMapCalledEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + entry_.Freeze(); + } + + public const int EntryFieldNumber = 1; + private static readonly pbc::MapField<int, int>.Codec _map_entry_codec + = new pbc::MapField<int, int>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForInt32(16), 10); + private readonly pbc::MapField<int, int> entry_ = new pbc::MapField<int, int>(); + public pbc::MapField<int, int> Entry { + get { return entry_; } + } + + public override bool Equals(object other) { + return Equals(other as MessageContainingMapCalledEntry); + } + + public bool Equals(MessageContainingMapCalledEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!Entry.Equals(other.Entry)) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + hash ^= Entry.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + entry_.WriteTo(output, _map_entry_codec); + } + + public int CalculateSize() { + int size = 0; + size += entry_.CalculateSize(_map_entry_codec); + return size; + } + + public void MergeFrom(MessageContainingMapCalledEntry other) { + if (other == null) { + return; + } + entry_.Add(other.entry_); + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 10: { + entry_.AddEntriesFrom(input, _map_entry_codec); + break; + } + } + } + } + + #region Nested types + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public static partial class Types { + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + public sealed partial class EntryEntry : pb::IMessage<EntryEntry> { + private static readonly pb::MessageParser<EntryEntry> _parser = new pb::MessageParser<EntryEntry>(() => new EntryEntry()); + public static pb::MessageParser<EntryEntry> Parser { get { return _parser; } } + + private static readonly string[] _fieldNames = new string[] { "key", "value" }; + private static readonly uint[] _fieldTags = new uint[] { 8, 16 }; + public static pbd::MessageDescriptor Descriptor { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_MessageContainingMapCalledEntry_EntryEntry__Descriptor; } + } + + public pb::FieldAccess.FieldAccessorTable<EntryEntry> Fields { + get { return global::Google.Protobuf.TestProtos.MapUnittestProto3.internal__static_protobuf_unittest_MessageContainingMapCalledEntry_EntryEntry__FieldAccessorTable; } + } + + private bool _frozen = false; + public bool IsFrozen { get { return _frozen; } } + + public EntryEntry() { } + + public EntryEntry(EntryEntry other) { + key_ = other.key_; + value_ = other.value_; + } + + public EntryEntry Clone() { + return new EntryEntry(this); + } + + public void Freeze() { + if (IsFrozen) { + return; + } + _frozen = true; + } + + public const int KeyFieldNumber = 1; + private int key_; + public int Key { + get { return key_; } + set { + pb::Freezable.CheckMutable(this); + key_ = value; + } + } + + public const int ValueFieldNumber = 2; + private int value_; + public int Value { + get { return value_; } + set { + pb::Freezable.CheckMutable(this); + value_ = value; + } + } + + public override bool Equals(object other) { + return Equals(other as EntryEntry); + } + + public bool Equals(EntryEntry other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return true; + } + + public override int GetHashCode() { + int hash = 1; + if (Key != 0) hash ^= Key.GetHashCode(); + if (Value != 0) hash ^= Value.GetHashCode(); + return hash; + } + + public void WriteTo(pb::CodedOutputStream output) { + if (Key != 0) { + output.WriteRawTag(8); + output.WriteInt32(Key); + } + if (Value != 0) { + output.WriteRawTag(16); + output.WriteInt32(Value); + } + } + + public int CalculateSize() { + int size = 0; + if (Key != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Key); + } + if (Value != 0) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Value); + } + return size; + } + + public void MergeFrom(EntryEntry other) { + if (other == null) { + return; + } + if (other.Key != 0) { + Key = other.Key; + } + if (other.Value != 0) { + Value = other.Value; + } + } + + public void MergeFrom(pb::CodedInputStream input) { + uint tag; + while (input.ReadTag(out tag)) { + switch(tag) { + case 0: + throw pb::InvalidProtocolBufferException.InvalidTag(); + default: + if (pb::WireFormat.IsEndGroupTag(tag)) { + return; + } + break; + case 8: { + Key = input.ReadInt32(); + break; + } + case 16: { + Value = input.ReadInt32(); + break; + } + } + } + } + + } + + } + #endregion + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportProto3.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportProto3.cs index a32d19c2..939be74a 100644 --- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportProto3.cs +++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportProto3.cs @@ -120,7 +120,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (D != 0) hash ^= D.GetHashCode(); return hash; } @@ -139,6 +139,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(ImportMessage other) { if (other == null) { return; diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportPublicProto3.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportPublicProto3.cs index 2c8b0a31..a5a33ea7 100644 --- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportPublicProto3.cs +++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestImportPublicProto3.cs @@ -105,7 +105,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (E != 0) hash ^= E.GetHashCode(); return hash; } @@ -124,6 +124,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(PublicImportMessage other) { if (other == null) { return; diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs index 28508a3b..73876b8c 100644 --- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs +++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs @@ -168,7 +168,7 @@ namespace UnitTest.Issues.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO) hash ^= Value.GetHashCode(); hash ^= values_.GetHashCode(); hash ^= packedValues_.GetHashCode(); @@ -212,6 +212,7 @@ namespace UnitTest.Issues.TestProtos { } return size; } + public void MergeFrom(NegativeEnumMessage other) { if (other == null) { return; @@ -303,7 +304,7 @@ namespace UnitTest.Issues.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; return hash; } @@ -314,6 +315,7 @@ namespace UnitTest.Issues.TestProtos { int size = 0; return size; } + public void MergeFrom(DeprecatedChild other) { if (other == null) { return; @@ -456,7 +458,7 @@ namespace UnitTest.Issues.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (PrimitiveValue != 0) hash ^= PrimitiveValue.GetHashCode(); hash ^= primitiveArray_.GetHashCode(); if (messageValue_ != null) hash ^= MessageValue.GetHashCode(); @@ -527,6 +529,7 @@ namespace UnitTest.Issues.TestProtos { } return size; } + public void MergeFrom(DeprecatedFieldsMessage other) { if (other == null) { return; @@ -655,7 +658,7 @@ namespace UnitTest.Issues.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Item != 0) hash ^= Item.GetHashCode(); return hash; } @@ -674,6 +677,7 @@ namespace UnitTest.Issues.TestProtos { } return size; } + public void MergeFrom(ItemField other) { if (other == null) { return; diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs index d758ef5c..1ae2d9a9 100644 --- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs +++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs @@ -995,7 +995,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (SingleInt32 != 0) hash ^= SingleInt32.GetHashCode(); if (SingleInt64 != 0L) hash ^= SingleInt64.GetHashCode(); if (SingleUint32 != 0) hash ^= SingleUint32.GetHashCode(); @@ -1472,6 +1472,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestAllTypes other) { if (other == null) { return; @@ -1905,7 +1906,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Bb != 0) hash ^= Bb.GetHashCode(); return hash; } @@ -1924,6 +1925,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(NestedMessage other) { if (other == null) { return; @@ -2043,7 +2045,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (child_ != null) hash ^= Child.GetHashCode(); if (payload_ != null) hash ^= Payload.GetHashCode(); hash ^= repeatedChild_.GetHashCode(); @@ -2080,6 +2082,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(NestedTestAllTypes other) { if (other == null) { return; @@ -2196,7 +2199,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (DeprecatedInt32 != 0) hash ^= DeprecatedInt32.GetHashCode(); return hash; } @@ -2215,6 +2218,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestDeprecatedFields other) { if (other == null) { return; @@ -2306,7 +2310,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (C != 0) hash ^= C.GetHashCode(); return hash; } @@ -2325,6 +2329,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(ForeignMessage other) { if (other == null) { return; @@ -2404,7 +2409,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; return hash; } @@ -2415,6 +2420,7 @@ namespace Google.Protobuf.TestProtos { int size = 0; return size; } + public void MergeFrom(TestReservedFields other) { if (other == null) { return; @@ -2500,7 +2506,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (foreignNested_ != null) hash ^= ForeignNested.GetHashCode(); return hash; } @@ -2519,6 +2525,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestForeignNested other) { if (other == null) { return; @@ -2628,7 +2635,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (A != 0) hash ^= A.GetHashCode(); if (Bb != 0) hash ^= Bb.GetHashCode(); return hash; @@ -2655,6 +2662,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestReallyLargeTagNumber other) { if (other == null) { return; @@ -2766,7 +2774,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (a_ != null) hash ^= A.GetHashCode(); if (I != 0) hash ^= I.GetHashCode(); return hash; @@ -2793,6 +2801,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestRecursiveMessage other) { if (other == null) { return; @@ -2898,7 +2907,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (bb_ != null) hash ^= Bb.GetHashCode(); return hash; } @@ -2917,6 +2926,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestMutualRecursionA other) { if (other == null) { return; @@ -3027,7 +3037,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (a_ != null) hash ^= A.GetHashCode(); if (OptionalInt32 != 0) hash ^= OptionalInt32.GetHashCode(); return hash; @@ -3054,6 +3064,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestMutualRecursionB other) { if (other == null) { return; @@ -3231,7 +3242,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (PrimitiveField != 0) hash ^= PrimitiveField.GetHashCode(); if (StringField.Length != 0) hash ^= StringField.GetHashCode(); if (EnumField != global::Google.Protobuf.TestProtos.ForeignEnum.FOREIGN_UNSPECIFIED) hash ^= EnumField.GetHashCode(); @@ -3322,6 +3333,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestCamelCaseFieldNames other) { if (other == null) { return; @@ -3499,7 +3511,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (MyString.Length != 0) hash ^= MyString.GetHashCode(); if (MyInt != 0L) hash ^= MyInt.GetHashCode(); if (MyFloat != 0F) hash ^= MyFloat.GetHashCode(); @@ -3542,6 +3554,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestFieldOrderings other) { if (other == null) { return; @@ -3673,7 +3686,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Oo != 0L) hash ^= Oo.GetHashCode(); if (Bb != 0) hash ^= Bb.GetHashCode(); return hash; @@ -3700,6 +3713,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(NestedMessage other) { if (other == null) { return; @@ -3803,7 +3817,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (SparseEnum != global::Google.Protobuf.TestProtos.TestSparseEnum.TEST_SPARSE_ENUM_UNSPECIFIED) hash ^= SparseEnum.GetHashCode(); return hash; } @@ -3822,6 +3836,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(SparseEnumMessage other) { if (other == null) { return; @@ -3913,7 +3928,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Data.Length != 0) hash ^= Data.GetHashCode(); return hash; } @@ -3932,6 +3947,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(OneString other) { if (other == null) { return; @@ -4020,7 +4036,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; hash ^= data_.GetHashCode(); return hash; } @@ -4043,6 +4059,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(MoreString other) { if (other == null) { return; @@ -4132,7 +4149,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Data.Length != 0) hash ^= Data.GetHashCode(); return hash; } @@ -4151,6 +4168,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(OneBytes other) { if (other == null) { return; @@ -4242,7 +4260,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Data.Length != 0) hash ^= Data.GetHashCode(); return hash; } @@ -4261,6 +4279,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(MoreBytes other) { if (other == null) { return; @@ -4352,7 +4371,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Data != 0) hash ^= Data.GetHashCode(); return hash; } @@ -4371,6 +4390,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(Int32Message other) { if (other == null) { return; @@ -4462,7 +4482,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Data != 0) hash ^= Data.GetHashCode(); return hash; } @@ -4481,6 +4501,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(Uint32Message other) { if (other == null) { return; @@ -4572,7 +4593,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Data != 0L) hash ^= Data.GetHashCode(); return hash; } @@ -4591,6 +4612,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(Int64Message other) { if (other == null) { return; @@ -4682,7 +4704,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Data != 0UL) hash ^= Data.GetHashCode(); return hash; } @@ -4701,6 +4723,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(Uint64Message other) { if (other == null) { return; @@ -4792,7 +4815,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Data != false) hash ^= Data.GetHashCode(); return hash; } @@ -4811,6 +4834,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(BoolMessage other) { if (other == null) { return; @@ -4954,7 +4978,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (fooCase_ == FooOneofCase.FooInt) hash ^= FooInt.GetHashCode(); if (fooCase_ == FooOneofCase.FooString) hash ^= FooString.GetHashCode(); if (fooCase_ == FooOneofCase.FooMessage) hash ^= FooMessage.GetHashCode(); @@ -4989,6 +5013,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestOneof other) { if (other == null) { return; @@ -5216,7 +5241,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; hash ^= packedInt32_.GetHashCode(); hash ^= packedInt64_.GetHashCode(); hash ^= packedUint32_.GetHashCode(); @@ -5395,6 +5420,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestPackedTypes other) { if (other == null) { return; @@ -5677,7 +5703,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; hash ^= unpackedInt32_.GetHashCode(); hash ^= unpackedInt64_.GetHashCode(); hash ^= unpackedUint32_.GetHashCode(); @@ -5842,6 +5868,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestUnpackedTypes other) { if (other == null) { return; @@ -6052,7 +6079,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; hash ^= repeatedFixed32_.GetHashCode(); hash ^= repeatedInt32_.GetHashCode(); hash ^= repeatedFixed64_.GetHashCode(); @@ -6135,6 +6162,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestRepeatedScalarDifferentTagSizes other) { if (other == null) { return; @@ -6255,7 +6283,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (A.Length != 0) hash ^= A.GetHashCode(); return hash; } @@ -6274,6 +6302,7 @@ namespace Google.Protobuf.TestProtos { } return size; } + public void MergeFrom(TestCommentInjectionMessage other) { if (other == null) { return; @@ -6353,7 +6382,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; return hash; } @@ -6364,6 +6393,7 @@ namespace Google.Protobuf.TestProtos { int size = 0; return size; } + public void MergeFrom(FooRequest other) { if (other == null) { return; @@ -6436,7 +6466,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; return hash; } @@ -6447,6 +6477,7 @@ namespace Google.Protobuf.TestProtos { int size = 0; return size; } + public void MergeFrom(FooResponse other) { if (other == null) { return; @@ -6519,7 +6550,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; return hash; } @@ -6530,6 +6561,7 @@ namespace Google.Protobuf.TestProtos { int size = 0; return size; } + public void MergeFrom(FooClientMessage other) { if (other == null) { return; @@ -6602,7 +6634,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; return hash; } @@ -6613,6 +6645,7 @@ namespace Google.Protobuf.TestProtos { int size = 0; return size; } + public void MergeFrom(FooServerMessage other) { if (other == null) { return; @@ -6685,7 +6718,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; return hash; } @@ -6696,6 +6729,7 @@ namespace Google.Protobuf.TestProtos { int size = 0; return size; } + public void MergeFrom(BarRequest other) { if (other == null) { return; @@ -6768,7 +6802,7 @@ namespace Google.Protobuf.TestProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; return hash; } @@ -6779,6 +6813,7 @@ namespace Google.Protobuf.TestProtos { int size = 0; return size; } + public void MergeFrom(BarResponse other) { if (other == null) { return; diff --git a/csharp/src/ProtocolBuffers/CodedInputStream.cs b/csharp/src/ProtocolBuffers/CodedInputStream.cs index 905cdb9d..dab3e5e3 100644 --- a/csharp/src/ProtocolBuffers/CodedInputStream.cs +++ b/csharp/src/ProtocolBuffers/CodedInputStream.cs @@ -456,14 +456,16 @@ namespace Google.Protobuf }
/// <summary>
- /// Returns true if the next tag is also part of the same unpacked array.
+ /// Peeks at the next tag in the stream. If it matches <paramref name="tag"/>,
+ /// the tag is consumed and the method returns <c>true</c>; otherwise, the
+ /// stream is left in the original position and the method returns <c>false</c>.
/// </summary>
- private bool ContinueArray(uint currentTag)
+ public bool MaybeConsumeTag(uint tag)
{
uint next;
if (PeekNextTag(out next))
{
- if (next == currentTag)
+ if (next == tag)
{
hasNextTag = false;
return true;
@@ -486,17 +488,7 @@ namespace Google.Protobuf }
return true;
}
-
- uint next;
- if (PeekNextTag(out next))
- {
- if (next == currentTag)
- {
- hasNextTag = false;
- return true;
- }
- }
- return false;
+ return MaybeConsumeTag(currentTag);
}
/// <summary>
@@ -512,7 +504,7 @@ namespace Google.Protobuf do
{
list.Add(ReadString());
- } while (ContinueArray(fieldTag));
+ } while (MaybeConsumeTag(fieldTag));
}
public void ReadBytesArray(ICollection<ByteString> list)
@@ -521,7 +513,7 @@ namespace Google.Protobuf do
{
list.Add(ReadBytes());
- } while (ContinueArray(fieldTag));
+ } while (MaybeConsumeTag(fieldTag));
}
public void ReadBoolArray(ICollection<bool> list)
@@ -729,7 +721,7 @@ namespace Google.Protobuf do
{
list.Add((T)(object) ReadEnum());
- } while (ContinueArray(fieldTag));
+ } while (MaybeConsumeTag(fieldTag));
}
}
@@ -742,7 +734,7 @@ namespace Google.Protobuf T message = messageParser.CreateTemplate();
ReadMessage(message);
list.Add(message);
- } while (ContinueArray(fieldTag));
+ } while (MaybeConsumeTag(fieldTag));
}
#endregion
diff --git a/csharp/src/ProtocolBuffers/CodedOutputStream.cs b/csharp/src/ProtocolBuffers/CodedOutputStream.cs index e56ce789..def874c0 100644 --- a/csharp/src/ProtocolBuffers/CodedOutputStream.cs +++ b/csharp/src/ProtocolBuffers/CodedOutputStream.cs @@ -476,6 +476,14 @@ namespace Google.Protobuf }
/// <summary>
+ /// Writes an already-encoded tag.
+ /// </summary>
+ public void WriteTag(uint tag)
+ {
+ WriteRawVarint32(tag);
+ }
+
+ /// <summary>
/// Writes the given single-byte tag directly to the stream.
/// </summary>
public void WriteRawTag(byte b1)
diff --git a/csharp/src/ProtocolBuffers/Collections/MapField.cs b/csharp/src/ProtocolBuffers/Collections/MapField.cs new file mode 100644 index 00000000..9eed833f --- /dev/null +++ b/csharp/src/ProtocolBuffers/Collections/MapField.cs @@ -0,0 +1,433 @@ +#region Copyright notice and license +// Protocol Buffers - Google's data interchange format +// Copyright 2015 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#endregion + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; + +namespace Google.Protobuf.Collections +{ + /// <summary> + /// Representation of a map field in a Protocol Buffer message. + /// </summary> + /// <remarks> + /// This implementation preserves insertion order for simplicity of testing + /// code using maps fields. Overwriting an existing entry does not change the + /// position of that entry within the map. Equality is not order-sensitive. + /// For string keys, the equality comparison is provided by <see cref="StringComparer.Ordinal"/>. + /// </remarks> + /// <typeparam name="TKey">Key type in the map. Must be a type supported by Protocol Buffer map keys.</typeparam> + /// <typeparam name="TValue">Value type in the map. Must be a type supported by Protocol Buffers.</typeparam> + public sealed class MapField<TKey, TValue> : IDeepCloneable<MapField<TKey, TValue>>, IFreezable, IDictionary<TKey, TValue>, IEquatable<MapField<TKey, TValue>> + { + // TODO: Don't create the map/list until we have an entry. (Assume many maps will be empty.) + private bool frozen; + private readonly Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>> map = + new Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>>(); + private readonly LinkedList<KeyValuePair<TKey, TValue>> list = new LinkedList<KeyValuePair<TKey, TValue>>(); + + public MapField<TKey, TValue> Clone() + { + var clone = new MapField<TKey, TValue>(); + // Keys are never cloneable. Values might be. + if (typeof(IDeepCloneable<TValue>).IsAssignableFrom(typeof(TValue))) + { + foreach (var pair in list) + { + clone.Add(pair.Key, pair.Value == null ? pair.Value : ((IDeepCloneable<TValue>) pair.Value).Clone()); + } + } + else + { + // Nothing is cloneable, so we don't need to worry. + clone.Add(this); + } + return clone; + } + + public void Add(TKey key, TValue value) + { + // Validation of arguments happens in ContainsKey and the indexer + if (ContainsKey(key)) + { + throw new ArgumentException("Key already exists in map", "key"); + } + this[key] = value; + } + + public bool ContainsKey(TKey key) + { + ThrowHelper.ThrowIfNull(key, "key"); + return map.ContainsKey(key); + } + + public bool Remove(TKey key) + { + this.CheckMutable(); + ThrowHelper.ThrowIfNull(key, "key"); + LinkedListNode<KeyValuePair<TKey, TValue>> node; + if (map.TryGetValue(key, out node)) + { + map.Remove(key); + node.List.Remove(node); + return true; + } + else + { + return false; + } + } + + public bool TryGetValue(TKey key, out TValue value) + { + LinkedListNode<KeyValuePair<TKey, TValue>> node; + if (map.TryGetValue(key, out node)) + { + value = node.Value.Value; + return true; + } + else + { + value = default(TValue); + return false; + } + } + + public TValue this[TKey key] + { + get + { + ThrowHelper.ThrowIfNull(key, "key"); + TValue value; + if (TryGetValue(key, out value)) + { + return value; + } + throw new KeyNotFoundException(); + } + set + { + ThrowHelper.ThrowIfNull(key, "key"); + if (value == null && (typeof(TValue) == typeof(ByteString) || typeof(TValue) == typeof(string))) + { + ThrowHelper.ThrowIfNull(value, "value"); + } + this.CheckMutable(); + LinkedListNode<KeyValuePair<TKey, TValue>> node; + var pair = new KeyValuePair<TKey, TValue>(key, value); + if (map.TryGetValue(key, out node)) + { + node.Value = pair; + } + else + { + node = list.AddLast(pair); + map[key] = node; + } + } + } + + // TODO: Make these views? + public ICollection<TKey> Keys { get { return list.Select(t => t.Key).ToList(); } } + public ICollection<TValue> Values { get { return list.Select(t => t.Value).ToList(); } } + + public void Add(IDictionary<TKey, TValue> entries) + { + ThrowHelper.ThrowIfNull(entries, "entries"); + foreach (var pair in entries) + { + Add(pair.Key, pair.Value); + } + } + + public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() + { + return list.GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item) + { + Add(item.Key, item.Value); + } + + public void Clear() + { + this.CheckMutable(); + list.Clear(); + map.Clear(); + } + + bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item) + { + TValue value; + return TryGetValue(item.Key, out value) + && EqualityComparer<TValue>.Default.Equals(item.Value, value); + } + + void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) + { + list.CopyTo(array, arrayIndex); + } + + bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item) + { + this.CheckMutable(); + if (item.Key == null) + { + throw new ArgumentException("Key is null", "item"); + } + LinkedListNode<KeyValuePair<TKey, TValue>> node; + if (map.TryGetValue(item.Key, out node) && + EqualityComparer<TValue>.Default.Equals(item.Value, node.Value.Value)) + { + map.Remove(item.Key); + node.List.Remove(node); + return true; + } + else + { + return false; + } + } + + public int Count { get { return list.Count; } } + public bool IsReadOnly { get { return frozen; } } + + public void Freeze() + { + if (IsFrozen) + { + return; + } + frozen = true; + // Only values can be frozen, as all the key types are simple. + // Everything can be done in-place, as we're just freezing objects. + if (typeof(IFreezable).IsAssignableFrom(typeof(TValue))) + { + for (var node = list.First; node != null; node = node.Next) + { + var pair = node.Value; + IFreezable freezableValue = pair.Value as IFreezable; + if (freezableValue != null) + { + freezableValue.Freeze(); + } + } + } + } + + public bool IsFrozen { get { return frozen; } } + + public override bool Equals(object other) + { + return Equals(other as MapField<TKey, TValue>); + } + + public override int GetHashCode() + { + var valueComparer = EqualityComparer<TValue>.Default; + int hash = 0; + foreach (var pair in list) + { + hash ^= pair.Key.GetHashCode() * 31 + valueComparer.GetHashCode(pair.Value); + } + return hash; + } + + public bool Equals(MapField<TKey, TValue> other) + { + if (other == null) + { + return false; + } + if (other == this) + { + return true; + } + if (other.Count != this.Count) + { + return false; + } + var valueComparer = EqualityComparer<TValue>.Default; + foreach (var pair in this) + { + TValue value; + if (!other.TryGetValue(pair.Key, out value)) + { + return false; + } + if (!valueComparer.Equals(value, pair.Value)) + { + return false; + } + } + return true; + } + + /// <summary> + /// Adds entries to the map from the given stream. + /// </summary> + /// <remarks> + /// It is assumed that the stream is initially positioned after the tag specified by the codec. + /// This method will continue reading entries from the stream until the end is reached, or + /// a different tag is encountered. + /// </remarks> + /// <param name="input">Stream to read from</param> + /// <param name="codec">Codec describing how the key/value pairs are encoded</param> + public void AddEntriesFrom(CodedInputStream input, Codec codec) + { + var adapter = new Codec.MessageAdapter(codec); + do + { + adapter.Reset(); + input.ReadMessage(adapter); + this[adapter.Key] = adapter.Value; + } while (input.MaybeConsumeTag(codec.MapTag)); + } + + public void WriteTo(CodedOutputStream output, Codec codec) + { + var message = new Codec.MessageAdapter(codec); + foreach (var entry in list) + { + message.Key = entry.Key; + message.Value = entry.Value; + output.WriteTag(codec.MapTag); + output.WriteMessage(message); + } + } + + public int CalculateSize(Codec codec) + { + var message = new Codec.MessageAdapter(codec); + int size = 0; + foreach (var entry in list) + { + message.Key = entry.Key; + message.Value = entry.Value; + size += CodedOutputStream.ComputeRawVarint32Size(codec.MapTag); + size += CodedOutputStream.ComputeMessageSize(message); + } + return size; + } + + /// <summary> + /// A codec for a specific map field. This contains all the information required to encoded and + /// decode the nested messages. + /// </summary> + public sealed class Codec + { + private readonly FieldCodec<TKey> keyCodec; + private readonly FieldCodec<TValue> valueCodec; + private readonly uint mapTag; + + public Codec(FieldCodec<TKey> keyCodec, FieldCodec<TValue> valueCodec, uint mapTag) + { + this.keyCodec = keyCodec; + this.valueCodec = valueCodec; + this.mapTag = mapTag; + } + + /// <summary> + /// The tag used in the enclosing message to indicate map entries. + /// </summary> + internal uint MapTag { get { return mapTag; } } + + /// <summary> + /// A mutable message class, used for parsing and serializing. This + /// delegates the work to a codec, but implements the <see cref="IMessage"/> interface + /// for interop with <see cref="CodedInputStream"/> and <see cref="CodedOutputStream"/>. + /// This is nested inside Codec as it's tightly coupled to the associated codec, + /// and it's simpler if it has direct access to all its fields. + /// </summary> + internal class MessageAdapter : IMessage + { + private readonly Codec codec; + internal TKey Key { get; set; } + internal TValue Value { get; set; } + + internal MessageAdapter(Codec codec) + { + this.codec = codec; + } + + internal void Reset() + { + Key = codec.keyCodec.DefaultValue; + Value = codec.valueCodec.DefaultValue; + } + + public void MergeFrom(CodedInputStream input) + { + uint tag; + while (input.ReadTag(out tag)) + { + if (tag == 0) + { + throw InvalidProtocolBufferException.InvalidTag(); + } + if (tag == codec.keyCodec.Tag) + { + Key = codec.keyCodec.Read(input); + } + else if (tag == codec.valueCodec.Tag) + { + Value = codec.valueCodec.Read(input); + } + else if (WireFormat.IsEndGroupTag(tag)) + { + // TODO(jonskeet): Do we need this? (Given that we don't support groups...) + return; + } + } + } + + public void WriteTo(CodedOutputStream output) + { + codec.keyCodec.Write(output, Key); + codec.valueCodec.Write(output, Value); + } + + public int CalculateSize() + { + return codec.keyCodec.CalculateSize(Key) + codec.valueCodec.CalculateSize(Value); + } + } + } + } +} diff --git a/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs b/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs index ebfc522f..4d4212cb 100644 --- a/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs +++ b/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs @@ -193,7 +193,7 @@ namespace Google.Protobuf.Collections public override int GetHashCode() { - int hash = 23; + int hash = 0; for (int i = 0; i < count; i++) { hash = hash * 31 + array[i].GetHashCode(); diff --git a/csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs b/csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs index eedb21fe..bc0419b0 100644 --- a/csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs +++ b/csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs @@ -335,7 +335,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; hash ^= file_.GetHashCode(); return hash; } @@ -356,6 +356,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(FileDescriptorSet other) { if (other == null) { return; @@ -558,7 +559,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); if (Package.Length != 0) hash ^= Package.GetHashCode(); hash ^= dependency_.GetHashCode(); @@ -685,6 +686,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(FileDescriptorProto other) { if (other == null) { return; @@ -938,7 +940,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); hash ^= field_.GetHashCode(); hash ^= extension_.GetHashCode(); @@ -1047,6 +1049,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(DescriptorProto other) { if (other == null) { return; @@ -1204,7 +1207,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Start != 0) hash ^= Start.GetHashCode(); if (End != 0) hash ^= End.GetHashCode(); return hash; @@ -1231,6 +1234,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(ExtensionRange other) { if (other == null) { return; @@ -1341,7 +1345,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Start != 0) hash ^= Start.GetHashCode(); if (End != 0) hash ^= End.GetHashCode(); return hash; @@ -1368,6 +1372,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(ReservedRange other) { if (other == null) { return; @@ -1568,7 +1573,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); if (Number != 0) hash ^= Number.GetHashCode(); if (Label != global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Types.Label.LABEL_OPTIONAL) hash ^= Label.GetHashCode(); @@ -1651,6 +1656,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(FieldDescriptorProto other) { if (other == null) { return; @@ -1837,7 +1843,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); return hash; } @@ -1856,6 +1862,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(OneofDescriptorProto other) { if (other == null) { return; @@ -1969,7 +1976,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); hash ^= value_.GetHashCode(); if (options_ != null) hash ^= Options.GetHashCode(); @@ -2006,6 +2013,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(EnumDescriptorProto other) { if (other == null) { return; @@ -2140,7 +2148,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); if (Number != 0) hash ^= Number.GetHashCode(); if (options_ != null) hash ^= Options.GetHashCode(); @@ -2175,6 +2183,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(EnumValueDescriptorProto other) { if (other == null) { return; @@ -2308,7 +2317,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); hash ^= method_.GetHashCode(); if (options_ != null) hash ^= Options.GetHashCode(); @@ -2345,6 +2354,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(ServiceDescriptorProto other) { if (other == null) { return; @@ -2515,7 +2525,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Name.Length != 0) hash ^= Name.GetHashCode(); if (InputType.Length != 0) hash ^= InputType.GetHashCode(); if (OutputType.Length != 0) hash ^= OutputType.GetHashCode(); @@ -2574,6 +2584,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(MethodDescriptorProto other) { if (other == null) { return; @@ -2871,7 +2882,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (JavaPackage.Length != 0) hash ^= JavaPackage.GetHashCode(); if (JavaOuterClassname.Length != 0) hash ^= JavaOuterClassname.GetHashCode(); if (JavaMultipleFiles != false) hash ^= JavaMultipleFiles.GetHashCode(); @@ -3004,6 +3015,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(FileOptions other) { if (other == null) { return; @@ -3248,7 +3260,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (MessageSetWireFormat != false) hash ^= MessageSetWireFormat.GetHashCode(); if (NoStandardDescriptorAccessor != false) hash ^= NoStandardDescriptorAccessor.GetHashCode(); if (Deprecated != false) hash ^= Deprecated.GetHashCode(); @@ -3301,6 +3313,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(MessageOptions other) { if (other == null) { return; @@ -3487,7 +3500,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Ctype != global::Google.Protobuf.DescriptorProtos.FieldOptions.Types.CType.STRING) hash ^= Ctype.GetHashCode(); if (Packed != false) hash ^= Packed.GetHashCode(); if (Jstype != global::Google.Protobuf.DescriptorProtos.FieldOptions.Types.JSType.JS_NORMAL) hash ^= Jstype.GetHashCode(); @@ -3556,6 +3569,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(FieldOptions other) { if (other == null) { return; @@ -3726,7 +3740,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (AllowAlias != false) hash ^= AllowAlias.GetHashCode(); if (Deprecated != false) hash ^= Deprecated.GetHashCode(); hash ^= uninterpretedOption_.GetHashCode(); @@ -3763,6 +3777,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(EnumOptions other) { if (other == null) { return; @@ -3875,7 +3890,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Deprecated != false) hash ^= Deprecated.GetHashCode(); hash ^= uninterpretedOption_.GetHashCode(); return hash; @@ -3904,6 +3919,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(EnumValueOptions other) { if (other == null) { return; @@ -4009,7 +4025,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Deprecated != false) hash ^= Deprecated.GetHashCode(); hash ^= uninterpretedOption_.GetHashCode(); return hash; @@ -4038,6 +4054,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(ServiceOptions other) { if (other == null) { return; @@ -4143,7 +4160,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (Deprecated != false) hash ^= Deprecated.GetHashCode(); hash ^= uninterpretedOption_.GetHashCode(); return hash; @@ -4172,6 +4189,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(MethodOptions other) { if (other == null) { return; @@ -4337,7 +4355,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; hash ^= name_.GetHashCode(); if (IdentifierValue.Length != 0) hash ^= IdentifierValue.GetHashCode(); if (PositiveIntValue != 0UL) hash ^= PositiveIntValue.GetHashCode(); @@ -4406,6 +4424,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(UninterpretedOption other) { if (other == null) { return; @@ -4550,7 +4569,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; if (NamePart_.Length != 0) hash ^= NamePart_.GetHashCode(); if (IsExtension != false) hash ^= IsExtension.GetHashCode(); return hash; @@ -4577,6 +4596,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(NamePart other) { if (other == null) { return; @@ -4677,7 +4697,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; hash ^= location_.GetHashCode(); return hash; } @@ -4698,6 +4718,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(SourceCodeInfo other) { if (other == null) { return; @@ -4827,7 +4848,7 @@ namespace Google.Protobuf.DescriptorProtos { } public override int GetHashCode() { - int hash = 0; + int hash = 1; hash ^= path_.GetHashCode(); hash ^= span_.GetHashCode(); if (LeadingComments.Length != 0) hash ^= LeadingComments.GetHashCode(); @@ -4892,6 +4913,7 @@ namespace Google.Protobuf.DescriptorProtos { } return size; } + public void MergeFrom(Location other) { if (other == null) { return; diff --git a/csharp/src/ProtocolBuffers/FieldCodec.cs b/csharp/src/ProtocolBuffers/FieldCodec.cs new file mode 100644 index 00000000..4cab9cc4 --- /dev/null +++ b/csharp/src/ProtocolBuffers/FieldCodec.cs @@ -0,0 +1,188 @@ +using System; +using System.Collections.Generic; + +namespace Google.Protobuf +{ + /// <summary> + /// Factory methods for <see cref="FieldCodec{T}"/>. + /// </summary> + public static class FieldCodec + { + public static FieldCodec<string> ForString(uint tag) + { + return new FieldCodec<string>(input => input.ReadString(), (output, value) => output.WriteString(value), CodedOutputStream.ComputeStringSize, tag); + } + + public static FieldCodec<ByteString> ForBytes(uint tag) + { + return new FieldCodec<ByteString>(input => input.ReadBytes(), (output, value) => output.WriteBytes(value), CodedOutputStream.ComputeBytesSize, tag); + } + + public static FieldCodec<bool> ForBool(uint tag) + { + return new FieldCodec<bool>(input => input.ReadBool(), (output, value) => output.WriteBool(value), CodedOutputStream.ComputeBoolSize, tag); + } + + public static FieldCodec<int> ForInt32(uint tag) + { + return new FieldCodec<int>(input => input.ReadInt32(), (output, value) => output.WriteInt32(value), CodedOutputStream.ComputeInt32Size, tag); + } + + public static FieldCodec<int> ForSInt32(uint tag) + { + return new FieldCodec<int>(input => input.ReadSInt32(), (output, value) => output.WriteSInt32(value), CodedOutputStream.ComputeSInt32Size, tag); + } + + public static FieldCodec<uint> ForFixed32(uint tag) + { + return new FieldCodec<uint>(input => input.ReadFixed32(), (output, value) => output.WriteFixed32(value), CodedOutputStream.ComputeFixed32Size, tag); + } + + public static FieldCodec<int> ForSFixed32(uint tag) + { + return new FieldCodec<int>(input => input.ReadSFixed32(), (output, value) => output.WriteSFixed32(value), CodedOutputStream.ComputeSFixed32Size, tag); + } + + public static FieldCodec<uint> ForUInt32(uint tag) + { + return new FieldCodec<uint>(input => input.ReadUInt32(), (output, value) => output.WriteUInt32(value), CodedOutputStream.ComputeUInt32Size, tag); + } + + public static FieldCodec<long> ForInt64(uint tag) + { + return new FieldCodec<long>(input => input.ReadInt64(), (output, value) => output.WriteInt64(value), CodedOutputStream.ComputeInt64Size, tag); + } + + public static FieldCodec<long> ForSInt64(uint tag) + { + return new FieldCodec<long>(input => input.ReadSInt64(), (output, value) => output.WriteSInt64(value), CodedOutputStream.ComputeSInt64Size, tag); + } + + public static FieldCodec<ulong> ForFixed64(uint tag) + { + return new FieldCodec<ulong>(input => input.ReadFixed64(), (output, value) => output.WriteFixed64(value), CodedOutputStream.ComputeFixed64Size, tag); + } + + public static FieldCodec<long> ForSFixed64(uint tag) + { + return new FieldCodec<long>(input => input.ReadSFixed64(), (output, value) => output.WriteSFixed64(value), CodedOutputStream.ComputeSFixed64Size, tag); + } + + public static FieldCodec<ulong> ForUInt64(uint tag) + { + return new FieldCodec<ulong>(input => input.ReadUInt64(), (output, value) => output.WriteUInt64(value), CodedOutputStream.ComputeUInt64Size, tag); + } + + public static FieldCodec<float> ForFloat(uint tag) + { + return new FieldCodec<float>(input => input.ReadFloat(), (output, value) => output.WriteFloat(value), CodedOutputStream.ComputeFloatSize, tag); + } + + public static FieldCodec<double> ForDouble(uint tag) + { + return new FieldCodec<double>(input => input.ReadDouble(), (output, value) => output.WriteDouble(value), CodedOutputStream.ComputeDoubleSize, tag); + } + + // Enums are tricky. We can probably use expression trees to build these delegates automatically, + // but it's easy to generate the code fdor it. + public static FieldCodec<T> ForEnum<T>(uint tag, Func<T, int> toInt32, Func<int, T> fromInt32) + { + return new FieldCodec<T>(input => fromInt32( + input.ReadEnum()), + (output, value) => output.WriteEnum(toInt32(value)), + value => CodedOutputStream.ComputeEnumSize(toInt32(value)), tag); + } + + public static FieldCodec<T> ForMessage<T>(uint tag, MessageParser<T> parser) where T : IMessage<T> + { + return new FieldCodec<T>(input => { T message = parser.CreateTemplate(); input.ReadMessage(message); return message; }, + (output, value) => output.WriteMessage(value), message => CodedOutputStream.ComputeMessageSize(message), tag); + } + } + + /// <summary> + /// An encode/decode pair for a single field. This effectively encapsulates + /// all the information needed to read or write the field value from/to a coded + /// stream. + /// </summary> + /// <remarks> + /// This never writes default values to the stream, and is not currently designed + /// to play well with packed arrays. + /// </remarks> + public sealed class FieldCodec<T> + { + private static readonly Func<T, bool> IsDefault; + private static readonly T Default; + + static FieldCodec() + { + if (typeof(T) == typeof(string)) + { + Default = (T)(object)""; + IsDefault = CreateDefaultValueCheck<string>(x => x.Length == 0); + } + else if (typeof(T) == typeof(ByteString)) + { + Default = (T)(object)ByteString.Empty; + IsDefault = CreateDefaultValueCheck<ByteString>(x => x.Length == 0); + } + else if (!typeof(T).IsValueType) + { + // Default default + IsDefault = CreateDefaultValueCheck<T>(x => x == null); + } + else + { + // Default default + IsDefault = CreateDefaultValueCheck<T>(x => EqualityComparer<T>.Default.Equals(x, default(T))); + } + } + + private static Func<T, bool> CreateDefaultValueCheck<TTmp>(Func<TTmp, bool> check) + { + return (Func<T, bool>)(object)check; + } + + private readonly Func<CodedInputStream, T> reader; + private readonly Action<CodedOutputStream, T> writer; + private readonly Func<T, int> sizeComputer; + private readonly uint tag; + private readonly int tagSize; + + internal FieldCodec( + Func<CodedInputStream, T> reader, + Action<CodedOutputStream, T> writer, + Func<T, int> sizeComputer, + uint tag) + { + this.reader = reader; + this.writer = writer; + this.sizeComputer = sizeComputer; + this.tag = tag; + tagSize = CodedOutputStream.ComputeRawVarint32Size(tag); + } + + public uint Tag { get { return tag; } } + + public T DefaultValue { get { return Default; } } + + public void Write(CodedOutputStream output, T value) + { + if (!IsDefault(value)) + { + output.WriteTag(tag); + writer(output, value); + } + } + + public T Read(CodedInputStream input) + { + return reader(input); + } + + public int CalculateSize(T value) + { + return IsDefault(value) ? 0 : sizeComputer(value) + CodedOutputStream.ComputeRawVarint32Size(tag); + } + } +} diff --git a/csharp/src/ProtocolBuffers/ProtocolBuffers.csproj b/csharp/src/ProtocolBuffers/ProtocolBuffers.csproj index d1551148..5edeff70 100644 --- a/csharp/src/ProtocolBuffers/ProtocolBuffers.csproj +++ b/csharp/src/ProtocolBuffers/ProtocolBuffers.csproj @@ -60,6 +60,7 @@ <Compile Include="CodedOutputStream.cs" />
<Compile Include="Collections\Dictionaries.cs" />
<Compile Include="Collections\Lists.cs" />
+ <Compile Include="Collections\MapField.cs" />
<Compile Include="Collections\ReadOnlyDictionary.cs" />
<Compile Include="Collections\RepeatedField.cs" />
<Compile Include="Collections\RepeatedFieldExtensions.cs" />
@@ -84,6 +85,7 @@ <Compile Include="Descriptors\MethodDescriptor.cs" />
<Compile Include="Descriptors\PackageDescriptor.cs" />
<Compile Include="Descriptors\ServiceDescriptor.cs" />
+ <Compile Include="FieldCodec.cs" />
<Compile Include="FrameworkPortability.cs" />
<Compile Include="Freezable.cs" />
<Compile Include="MessageExtensions.cs" />
diff --git a/src/Makefile.am b/src/Makefile.am index 866af48a..cea3089e 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -425,6 +425,8 @@ libprotoc_la_SOURCES = \ google/protobuf/compiler/csharp/csharp_generator.cc \ google/protobuf/compiler/csharp/csharp_helpers.cc \ google/protobuf/compiler/csharp/csharp_helpers.h \ + google/protobuf/compiler/csharp/csharp_map_field.cc \ + google/protobuf/compiler/csharp/csharp_map_field.h \ google/protobuf/compiler/csharp/csharp_message.cc \ google/protobuf/compiler/csharp/csharp_message.h \ google/protobuf/compiler/csharp/csharp_message_field.cc \ diff --git a/src/google/protobuf/compiler/csharp/csharp_enum_field.cc b/src/google/protobuf/compiler/csharp/csharp_enum_field.cc index af34f50c..d38fb1ed 100644 --- a/src/google/protobuf/compiler/csharp/csharp_enum_field.cc +++ b/src/google/protobuf/compiler/csharp/csharp_enum_field.cc @@ -74,6 +74,12 @@ void EnumFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) { "}\n"); } +void EnumFieldGenerator::GenerateCodecCode(io::Printer* printer) { + printer->Print( + variables_, + "pb::FieldCodec.ForEnum($tag$, x => (int) x, x => ($type_name$) x)"); +} + EnumOneofFieldGenerator::EnumOneofFieldGenerator(const FieldDescriptor* descriptor, int fieldOrdinal) : PrimitiveOneofFieldGenerator(descriptor, fieldOrdinal) { diff --git a/src/google/protobuf/compiler/csharp/csharp_enum_field.h b/src/google/protobuf/compiler/csharp/csharp_enum_field.h index e627b7cc..08364157 100644 --- a/src/google/protobuf/compiler/csharp/csharp_enum_field.h +++ b/src/google/protobuf/compiler/csharp/csharp_enum_field.h @@ -46,6 +46,7 @@ class EnumFieldGenerator : public PrimitiveFieldGenerator { EnumFieldGenerator(const FieldDescriptor* descriptor, int fieldOrdinal); ~EnumFieldGenerator(); + virtual void GenerateCodecCode(io::Printer* printer); virtual void GenerateParsingCode(io::Printer* printer); virtual void GenerateSerializationCode(io::Printer* printer); virtual void GenerateSerializedSizeCode(io::Printer* printer); diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.cc b/src/google/protobuf/compiler/csharp/csharp_field_base.cc index c716e1bf..bfb39a64 100644 --- a/src/google/protobuf/compiler/csharp/csharp_field_base.cc +++ b/src/google/protobuf/compiler/csharp/csharp_field_base.cc @@ -65,6 +65,7 @@ void FieldGeneratorBase::SetCommonFieldVariables( tag_bytes += ", " + SimpleItoa(tag_array[i]); } + (*variables)["tag"] = SimpleItoa(tag); (*variables)["tag_size"] = SimpleItoa(tag_size); (*variables)["tag_bytes"] = tag_bytes; @@ -112,6 +113,11 @@ void FieldGeneratorBase::GenerateFreezingCode(io::Printer* printer) { // special handling for freezing, so default to not generating any code. } +void FieldGeneratorBase::GenerateCodecCode(io::Printer* printer) { + // No-op: expect this to be overridden by appropriate types. + // Could fail if we get called here though... +} + void FieldGeneratorBase::AddDeprecatedFlag(io::Printer* printer) { if (descriptor_->options().deprecated()) { @@ -151,12 +157,16 @@ std::string FieldGeneratorBase::name() { } std::string FieldGeneratorBase::type_name() { - switch (descriptor_->type()) { + return type_name(descriptor_); +} + +std::string FieldGeneratorBase::type_name(const FieldDescriptor* descriptor) { + switch (descriptor->type()) { case FieldDescriptor::TYPE_ENUM: - return GetClassName(descriptor_->enum_type()); + return GetClassName(descriptor->enum_type()); case FieldDescriptor::TYPE_MESSAGE: case FieldDescriptor::TYPE_GROUP: - return GetClassName(descriptor_->message_type()); + return GetClassName(descriptor->message_type()); case FieldDescriptor::TYPE_DOUBLE: return "double"; case FieldDescriptor::TYPE_FLOAT: diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.h b/src/google/protobuf/compiler/csharp/csharp_field_base.h index abf9254b..349d835b 100644 --- a/src/google/protobuf/compiler/csharp/csharp_field_base.h +++ b/src/google/protobuf/compiler/csharp/csharp_field_base.h @@ -49,6 +49,7 @@ class FieldGeneratorBase : public SourceGeneratorBase { virtual void GenerateCloningCode(io::Printer* printer) = 0; virtual void GenerateFreezingCode(io::Printer* printer); + virtual void GenerateCodecCode(io::Printer* printer); virtual void GenerateMembers(io::Printer* printer) = 0; virtual void GenerateMergingCode(io::Printer* printer) = 0; virtual void GenerateParsingCode(io::Printer* printer) = 0; @@ -76,6 +77,7 @@ class FieldGeneratorBase : public SourceGeneratorBase { std::string property_name(); std::string name(); std::string type_name(); + std::string type_name(const FieldDescriptor* descriptor); bool has_default_value(); bool is_nullable_type(); std::string default_value(); diff --git a/src/google/protobuf/compiler/csharp/csharp_helpers.cc b/src/google/protobuf/compiler/csharp/csharp_helpers.cc index 39a53268..927fea97 100644 --- a/src/google/protobuf/compiler/csharp/csharp_helpers.cc +++ b/src/google/protobuf/compiler/csharp/csharp_helpers.cc @@ -46,6 +46,7 @@ #include <google/protobuf/compiler/csharp/csharp_field_base.h> #include <google/protobuf/compiler/csharp/csharp_enum_field.h> +#include <google/protobuf/compiler/csharp/csharp_map_field.h> #include <google/protobuf/compiler/csharp/csharp_message_field.h> #include <google/protobuf/compiler/csharp/csharp_primitive_field.h> #include <google/protobuf/compiler/csharp/csharp_repeated_enum_field.h> @@ -355,7 +356,11 @@ FieldGeneratorBase* CreateFieldGenerator(const FieldDescriptor* descriptor, case FieldDescriptor::TYPE_GROUP: case FieldDescriptor::TYPE_MESSAGE: if (descriptor->is_repeated()) { - return new RepeatedMessageFieldGenerator(descriptor, fieldOrdinal); + if (descriptor->is_map()) { + return new MapFieldGenerator(descriptor, fieldOrdinal); + } else { + return new RepeatedMessageFieldGenerator(descriptor, fieldOrdinal); + } } else { if (descriptor->containing_oneof()) { return new MessageOneofFieldGenerator(descriptor, fieldOrdinal); diff --git a/src/google/protobuf/compiler/csharp/csharp_map_field.cc b/src/google/protobuf/compiler/csharp/csharp_map_field.cc new file mode 100644 index 00000000..b8f1592c --- /dev/null +++ b/src/google/protobuf/compiler/csharp/csharp_map_field.cc @@ -0,0 +1,141 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2015 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include <sstream> + +#include <google/protobuf/compiler/code_generator.h> +#include <google/protobuf/compiler/plugin.h> +#include <google/protobuf/descriptor.h> +#include <google/protobuf/descriptor.pb.h> +#include <google/protobuf/io/printer.h> +#include <google/protobuf/io/zero_copy_stream.h> +#include <google/protobuf/stubs/strutil.h> + +#include <google/protobuf/compiler/csharp/csharp_helpers.h> +#include <google/protobuf/compiler/csharp/csharp_map_field.h> + +namespace google { +namespace protobuf { +namespace compiler { +namespace csharp { + +MapFieldGenerator::MapFieldGenerator(const FieldDescriptor* descriptor, + int fieldOrdinal) + : FieldGeneratorBase(descriptor, fieldOrdinal) { +} + +MapFieldGenerator::~MapFieldGenerator() { +} + +void MapFieldGenerator::GenerateMembers(io::Printer* printer) { + const FieldDescriptor* key_descriptor = + descriptor_->message_type()->FindFieldByName("key"); + const FieldDescriptor* value_descriptor = + descriptor_->message_type()->FindFieldByName("value"); + variables_["key_type_name"] = type_name(key_descriptor); + variables_["value_type_name"] = type_name(value_descriptor); + scoped_ptr<FieldGeneratorBase> key_generator(CreateFieldGenerator(key_descriptor, 1)); + scoped_ptr<FieldGeneratorBase> value_generator(CreateFieldGenerator(value_descriptor, 2)); + + printer->Print( + variables_, + "private static readonly pbc::MapField<$key_type_name$, $value_type_name$>.Codec _map_$name$_codec\n" + " = new pbc::MapField<$key_type_name$, $value_type_name$>.Codec("); + key_generator->GenerateCodecCode(printer); + printer->Print(", "); + value_generator->GenerateCodecCode(printer); + printer->Print( + variables_, + ", $tag$);\n" + "private readonly pbc::MapField<$key_type_name$, $value_type_name$> $name$_ = new pbc::MapField<$key_type_name$, $value_type_name$>();\n"); + AddDeprecatedFlag(printer); + printer->Print( + variables_, + "public pbc::MapField<$key_type_name$, $value_type_name$> $property_name$ {\n" + " get { return $name$_; }\n" + "}\n"); +} + +void MapFieldGenerator::GenerateMergingCode(io::Printer* printer) { + printer->Print( + variables_, + "$name$_.Add(other.$name$_);\n"); +} + +void MapFieldGenerator::GenerateParsingCode(io::Printer* printer) { + printer->Print( + variables_, + "$name$_.AddEntriesFrom(input, _map_$name$_codec);\n"); +} + +void MapFieldGenerator::GenerateSerializationCode(io::Printer* printer) { + printer->Print( + variables_, + "$name$_.WriteTo(output, _map_$name$_codec);\n"); +} + +void MapFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) { + printer->Print( + variables_, + "size += $name$_.CalculateSize(_map_$name$_codec);\n"); +} + +void MapFieldGenerator::WriteHash(io::Printer* printer) { + printer->Print( + variables_, + "hash ^= $property_name$.GetHashCode();\n"); +} +void MapFieldGenerator::WriteEquals(io::Printer* printer) { + printer->Print( + variables_, + "if (!$property_name$.Equals(other.$property_name$)) return false;\n"); +} +void MapFieldGenerator::WriteToString(io::Printer* printer) { + /* + variables_["field_name"] = GetFieldName(descriptor_); + printer->Print( + variables_, + "PrintField(\"$field_name$\", has$property_name$, $name$_, writer);\n");*/ +} + +void MapFieldGenerator::GenerateCloningCode(io::Printer* printer) { + printer->Print(variables_, + "$name$_ = other.$name$_.Clone();\n"); +} + +void MapFieldGenerator::GenerateFreezingCode(io::Printer* printer) { + printer->Print(variables_, + "$name$_.Freeze();\n"); +} + +} // namespace csharp +} // namespace compiler +} // namespace protobuf +} // namespace google diff --git a/src/google/protobuf/compiler/csharp/csharp_map_field.h b/src/google/protobuf/compiler/csharp/csharp_map_field.h new file mode 100644 index 00000000..f33fe1c3 --- /dev/null +++ b/src/google/protobuf/compiler/csharp/csharp_map_field.h @@ -0,0 +1,71 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_MAP_FIELD_H__ +#define GOOGLE_PROTOBUF_COMPILER_CSHARP_MAP_FIELD_H__ + +#include <string> + +#include <google/protobuf/compiler/code_generator.h> +#include <google/protobuf/compiler/csharp/csharp_field_base.h> + +namespace google { +namespace protobuf { +namespace compiler { +namespace csharp { + +class MapFieldGenerator : public FieldGeneratorBase { + public: + MapFieldGenerator(const FieldDescriptor* descriptor, int fieldOrdinal); + ~MapFieldGenerator(); + + virtual void GenerateCloningCode(io::Printer* printer); + virtual void GenerateFreezingCode(io::Printer* printer); + virtual void GenerateMembers(io::Printer* printer); + virtual void GenerateMergingCode(io::Printer* printer); + virtual void GenerateParsingCode(io::Printer* printer); + virtual void GenerateSerializationCode(io::Printer* printer); + virtual void GenerateSerializedSizeCode(io::Printer* printer); + + virtual void WriteHash(io::Printer* printer); + virtual void WriteEquals(io::Printer* printer); + virtual void WriteToString(io::Printer* printer); + + private: + GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapFieldGenerator); +}; + +} // namespace csharp +} // namespace compiler +} // namespace protobuf +} // namespace google + +#endif // GOOGLE_PROTOBUF_COMPILER_CSHARP_MAP_FIELD_H__ + diff --git a/src/google/protobuf/compiler/csharp/csharp_message.cc b/src/google/protobuf/compiler/csharp/csharp_message.cc index a6c8e32b..9e2fe9b6 100644 --- a/src/google/protobuf/compiler/csharp/csharp_message.cc +++ b/src/google/protobuf/compiler/csharp/csharp_message.cc @@ -268,8 +268,6 @@ void MessageGenerator::Generate(io::Printer* printer) { "}\n\n"); } - // TODO(jonskeet): Map properties - // Standard methods GenerateFrameworkMethods(printer); GenerateMessageSerializationMethods(printer); @@ -299,7 +297,6 @@ void MessageGenerator::Generate(io::Printer* printer) { printer->Outdent(); printer->Print("}\n"); printer->Print("\n"); - } void MessageGenerator::GenerateCloningCode(io::Printer* printer) { @@ -408,9 +405,10 @@ void MessageGenerator::GenerateFrameworkMethods(io::Printer* printer) { "}\n\n"); // GetHashCode + // Start with a non-zero value to easily distinguish between null and "empty" messages. printer->Print( "public override int GetHashCode() {\n" - " int hash = 0;\n"); + " int hash = 1;\n"); printer->Indent(); for (int i = 0; i < descriptor_->field_count(); i++) { scoped_ptr<FieldGeneratorBase> generator( @@ -451,7 +449,7 @@ void MessageGenerator::GenerateMessageSerializationMethods(io::Printer* printer) } printer->Print("return size;\n"); printer->Outdent(); - printer->Print("}\n"); + printer->Print("}\n\n"); } void MessageGenerator::GenerateMergingMethods(io::Printer* printer) { @@ -469,7 +467,6 @@ void MessageGenerator::GenerateMergingMethods(io::Printer* printer) { "if (other == null) {\n" " return;\n" "}\n"); - // TODO(jonskeet): Maps? // Merge non-oneof fields for (int i = 0; i < descriptor_->field_count(); i++) { if (!descriptor_->field(i)->containing_oneof()) { diff --git a/src/google/protobuf/compiler/csharp/csharp_message_field.cc b/src/google/protobuf/compiler/csharp/csharp_message_field.cc index cbf182d2..d8c82271 100644 --- a/src/google/protobuf/compiler/csharp/csharp_message_field.cc +++ b/src/google/protobuf/compiler/csharp/csharp_message_field.cc @@ -138,6 +138,12 @@ void MessageFieldGenerator::GenerateFreezingCode(io::Printer* printer) { "if ($has_property_check$) $property_name$.Freeze();\n"); } +void MessageFieldGenerator::GenerateCodecCode(io::Printer* printer) { + printer->Print( + variables_, + "pb::FieldCodec.ForMessage($tag$, $type_name$.Parser)"); +} + MessageOneofFieldGenerator::MessageOneofFieldGenerator(const FieldDescriptor* descriptor, int fieldOrdinal) : MessageFieldGenerator(descriptor, fieldOrdinal) { diff --git a/src/google/protobuf/compiler/csharp/csharp_message_field.h b/src/google/protobuf/compiler/csharp/csharp_message_field.h index 3e17f92a..dc6e4dc5 100644 --- a/src/google/protobuf/compiler/csharp/csharp_message_field.h +++ b/src/google/protobuf/compiler/csharp/csharp_message_field.h @@ -46,6 +46,7 @@ class MessageFieldGenerator : public FieldGeneratorBase { MessageFieldGenerator(const FieldDescriptor* descriptor, int fieldOrdinal); ~MessageFieldGenerator(); + virtual void GenerateCodecCode(io::Printer* printer); virtual void GenerateCloningCode(io::Printer* printer); virtual void GenerateFreezingCode(io::Printer* printer); virtual void GenerateMembers(io::Printer* printer); diff --git a/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc b/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc index d5542f57..c40cba13 100644 --- a/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc +++ b/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc @@ -129,7 +129,7 @@ void PrimitiveFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) { "size += $tag_size$ + $fixed_size$;\n", "fixed_size", SimpleItoa(fixedSize), "tag_size", variables_["tag_size"]); - } + } printer->Outdent(); printer->Print("}\n"); } @@ -155,6 +155,12 @@ void PrimitiveFieldGenerator::GenerateCloningCode(io::Printer* printer) { "$name$_ = other.$name$_;\n"); } +void PrimitiveFieldGenerator::GenerateCodecCode(io::Printer* printer) { + printer->Print( + variables_, + "pb::FieldCodec.For$capitalized_type_name$($tag$)"); +} + PrimitiveOneofFieldGenerator::PrimitiveOneofFieldGenerator( const FieldDescriptor* descriptor, int fieldOrdinal) : PrimitiveFieldGenerator(descriptor, fieldOrdinal) { diff --git a/src/google/protobuf/compiler/csharp/csharp_primitive_field.h b/src/google/protobuf/compiler/csharp/csharp_primitive_field.h index bac33214..8b87ebc4 100644 --- a/src/google/protobuf/compiler/csharp/csharp_primitive_field.h +++ b/src/google/protobuf/compiler/csharp/csharp_primitive_field.h @@ -46,6 +46,7 @@ class PrimitiveFieldGenerator : public FieldGeneratorBase { PrimitiveFieldGenerator(const FieldDescriptor* descriptor, int fieldOrdinal); ~PrimitiveFieldGenerator(); + virtual void GenerateCodecCode(io::Printer* printer); virtual void GenerateCloningCode(io::Printer* printer); virtual void GenerateMembers(io::Printer* printer); virtual void GenerateMergingCode(io::Printer* printer); diff --git a/src/google/protobuf/map_unittest_proto3.proto b/src/google/protobuf/map_unittest_proto3.proto new file mode 100644 index 00000000..16be2773 --- /dev/null +++ b/src/google/protobuf/map_unittest_proto3.proto @@ -0,0 +1,120 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// This file is mostly equivalent to map_unittest.proto, but imports +// unittest_proto3.proto instead of unittest.proto, so that it only +// uses proto3 messages. This makes it suitable for testing +// implementations which only support proto3. +// The TestRequiredMessageMap message has been removed as there are no +// required fields in proto3. +syntax = "proto3"; + +option cc_enable_arenas = true; +option csharp_namespace = "Google.Protobuf.TestProtos"; + +import "google/protobuf/unittest_proto3.proto"; + +// We don't put this in a package within proto2 because we need to make sure +// that the generated code doesn't depend on being in the proto2 namespace. +// In map_test_util.h we do "using namespace unittest = protobuf_unittest". +package protobuf_unittest; + +// Tests maps. +message TestMap { + map<int32 , int32 > map_int32_int32 = 1; + map<int64 , int64 > map_int64_int64 = 2; + map<uint32 , uint32 > map_uint32_uint32 = 3; + map<uint64 , uint64 > map_uint64_uint64 = 4; + map<sint32 , sint32 > map_sint32_sint32 = 5; + map<sint64 , sint64 > map_sint64_sint64 = 6; + map<fixed32 , fixed32 > map_fixed32_fixed32 = 7; + map<fixed64 , fixed64 > map_fixed64_fixed64 = 8; + map<sfixed32, sfixed32> map_sfixed32_sfixed32 = 9; + map<sfixed64, sfixed64> map_sfixed64_sfixed64 = 10; + map<int32 , float > map_int32_float = 11; + map<int32 , double > map_int32_double = 12; + map<bool , bool > map_bool_bool = 13; + map<string , string > map_string_string = 14; + map<int32 , bytes > map_int32_bytes = 15; + map<int32 , MapEnum > map_int32_enum = 16; + map<int32 , ForeignMessage> map_int32_foreign_message = 17; +} + +message TestMapSubmessage { + TestMap test_map = 1; +} + +message TestMessageMap { + map<int32, TestAllTypes> map_int32_message = 1; +} + +// Two map fields share the same entry default instance. +message TestSameTypeMap { + map<int32, int32> map1 = 1; + map<int32, int32> map2 = 2; +} + +enum MapEnum { + MAP_ENUM_FOO = 0; + MAP_ENUM_BAR = 1; + MAP_ENUM_BAZ = 2; +} + +message TestArenaMap { + map<int32 , int32 > map_int32_int32 = 1; + map<int64 , int64 > map_int64_int64 = 2; + map<uint32 , uint32 > map_uint32_uint32 = 3; + map<uint64 , uint64 > map_uint64_uint64 = 4; + map<sint32 , sint32 > map_sint32_sint32 = 5; + map<sint64 , sint64 > map_sint64_sint64 = 6; + map<fixed32 , fixed32 > map_fixed32_fixed32 = 7; + map<fixed64 , fixed64 > map_fixed64_fixed64 = 8; + map<sfixed32, sfixed32> map_sfixed32_sfixed32 = 9; + map<sfixed64, sfixed64> map_sfixed64_sfixed64 = 10; + map<int32 , float > map_int32_float = 11; + map<int32 , double > map_int32_double = 12; + map<bool , bool > map_bool_bool = 13; + map<int32 , MapEnum > map_int32_enum = 14; + map<int32 , ForeignMessage> map_int32_foreign_message = 15; +} + +// Previously, message containing enum called Type cannot be used as value of +// map field. +message MessageContainingEnumCalledType { + enum Type { + TYPE_FOO = 0; + } + map<int32, MessageContainingEnumCalledType> type = 1; +} + +// Previously, message cannot contain map field called "entry". +message MessageContainingMapCalledEntry { + map<int32, int32> entry = 1; +} |