diff options
author | Jon Skeet <skeet@pobox.com> | 2015-07-09 07:53:04 +0100 |
---|---|---|
committer | Jon Skeet <skeet@pobox.com> | 2015-07-09 07:53:04 +0100 |
commit | 4ae9b6c0d1e7317f9dc7420230ebcef605275caf (patch) | |
tree | 416cceb9b343b21004b030deea069553644928d3 /csharp/src/ProtocolBuffers.Test | |
parent | 241e17ba78b71a7ecccb289914ecaeab203b2373 (diff) | |
parent | f34d37a3d4d64621bc87aa0a65a05cab64062399 (diff) | |
download | protobuf-4ae9b6c0d1e7317f9dc7420230ebcef605275caf.tar.gz protobuf-4ae9b6c0d1e7317f9dc7420230ebcef605275caf.tar.bz2 protobuf-4ae9b6c0d1e7317f9dc7420230ebcef605275caf.zip |
Merge pull request #560 from jskeet/csharp-repeated
Large changes to repeated field handling
Diffstat (limited to 'csharp/src/ProtocolBuffers.Test')
10 files changed, 929 insertions, 1008 deletions
diff --git a/csharp/src/ProtocolBuffers.Test/CodedInputStreamExtensions.cs b/csharp/src/ProtocolBuffers.Test/CodedInputStreamExtensions.cs new file mode 100644 index 00000000..408c7cb9 --- /dev/null +++ b/csharp/src/ProtocolBuffers.Test/CodedInputStreamExtensions.cs @@ -0,0 +1,54 @@ +#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 NUnit.Framework; + +namespace Google.Protobuf +{ + internal static class CodedInputStreamExtensions + { + public static void AssertNextTag(this CodedInputStream input, uint expectedTag) + { + uint tag; + Assert.IsTrue(input.ReadTag(out tag)); + Assert.AreEqual(expectedTag, tag); + } + + public static T ReadMessage<T>(this CodedInputStream stream, MessageParser<T> parser) + where T : IMessage<T> + { + var message = parser.CreateTemplate(); + stream.ReadMessage(message); + return message; + } + } +} diff --git a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs index 52757d4d..a64994fd 100644 --- a/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs +++ b/csharp/src/ProtocolBuffers.Test/CodedInputStreamTest.cs @@ -35,10 +35,8 @@ #endregion
using System;
-using System.Collections.Generic;
using System.IO;
using Google.Protobuf.Collections;
-using Google.Protobuf.Descriptors;
using Google.Protobuf.TestProtos;
using NUnit.Framework;
@@ -62,7 +60,7 @@ namespace Google.Protobuf }
/// <summary>
- /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and
+ /// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64()
/// </summary>
private static void AssertReadVarint(byte[] data, ulong value)
{
@@ -232,66 +230,26 @@ namespace Google.Protobuf Assert.AreEqual(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL));
Assert.AreEqual(unchecked((long) 0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL));
}
- /*
+
[Test]
- public void ReadWholeMessage()
+ public void ReadWholeMessage_VaryingBlockSizes()
{
- TestAllTypes message = TestUtil.GetAllSet();
+ TestAllTypes message = GeneratedMessageTest.GetSampleMessage();
byte[] rawBytes = message.ToByteArray();
- Assert.AreEqual(rawBytes.Length, message.SerializedSize);
- TestAllTypes message2 = TestAllTypes.ParseFrom(rawBytes);
- TestUtil.AssertAllFieldsSet(message2);
+ Assert.AreEqual(rawBytes.Length, message.CalculateSize());
+ TestAllTypes message2 = TestAllTypes.Parser.ParseFrom(rawBytes);
+ Assert.AreEqual(message, message2);
// Try different block sizes.
for (int blockSize = 1; blockSize < 256; blockSize *= 2)
{
- message2 = TestAllTypes.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize));
- TestUtil.AssertAllFieldsSet(message2);
+ message2 = TestAllTypes.Parser.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize));
+ Assert.AreEqual(message, message2);
}
}
-
+
[Test]
- public void SkipWholeMessage()
- {
- TestAllTypes message = TestUtil.GetAllSet();
- byte[] rawBytes = message.ToByteArray();
-
- // Create two parallel inputs. Parse one as unknown fields while using
- // skipField() to skip each field on the other. Expect the same tags.
- CodedInputStream input1 = CodedInputStream.CreateInstance(rawBytes);
- CodedInputStream input2 = CodedInputStream.CreateInstance(rawBytes);
- UnknownFieldSet.Builder unknownFields = UnknownFieldSet.CreateBuilder();
-
- uint tag;
- string name;
- while (input1.ReadTag(out tag, out name))
- {
- uint tag2;
- Assert.IsTrue(input2.ReadTag(out tag2, out name));
- Assert.AreEqual(tag, tag2);
-
- unknownFields.MergeFieldFrom(tag, input1);
- input2.SkipField();
- }
- }*/
-
- /// <summary>
- /// Test that a bug in SkipRawBytes has been fixed: if the skip
- /// skips exactly up to a limit, this should bnot break things
- /// </summary>
- [Test]
- public void SkipRawBytesBug()
- {
- byte[] rawBytes = new byte[] {1, 2};
- CodedInputStream input = CodedInputStream.CreateInstance(rawBytes);
-
- int limit = input.PushLimit(1);
- input.SkipRawBytes(1);
- input.PopLimit(limit);
- Assert.AreEqual(2, input.ReadRawByte());
- }
- /*
public void ReadHugeBlob()
{
// Allocate and initialize a 1MB blob.
@@ -302,24 +260,15 @@ namespace Google.Protobuf }
// Make a message containing it.
- TestAllTypes.Builder builder = TestAllTypes.CreateBuilder();
- TestUtil.SetAllFields(builder);
- builder.SetOptionalBytes(ByteString.CopyFrom(blob));
- TestAllTypes message = builder.Build();
+ var message = new TestAllTypes { SingleBytes = ByteString.CopyFrom(blob) };
// Serialize and parse it. Make sure to parse from an InputStream, not
// directly from a ByteString, so that CodedInputStream uses buffered
// reading.
- TestAllTypes message2 = TestAllTypes.ParseFrom(message.ToByteString().CreateCodedInput());
+ TestAllTypes message2 = TestAllTypes.Parser.ParseFrom(message.ToByteString());
- Assert.AreEqual(message.OptionalBytes, message2.OptionalBytes);
-
- // Make sure all the other fields were parsed correctly.
- TestAllTypes message3 = TestAllTypes.CreateBuilder(message2)
- .SetOptionalBytes(TestUtil.GetAllSet().OptionalBytes)
- .Build();
- TestUtil.AssertAllFieldsSet(message3);
- }*/
+ Assert.AreEqual(message, message2);
+ }
[Test]
public void ReadMaliciouslyLargeBlob()
@@ -461,66 +410,15 @@ namespace Google.Protobuf }
}
- enum TestNegEnum { None = 0, Value = -2 }
-
[Test]
public void TestNegativeEnum()
{
- byte[] bytes = new byte[10] { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 };
+ byte[] bytes = { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 };
CodedInputStream input = CodedInputStream.CreateInstance(bytes);
- Assert.AreEqual((int)TestNegEnum.Value, input.ReadEnum());
+ Assert.AreEqual((int)SampleEnum.NegativeValue, input.ReadEnum());
Assert.IsTrue(input.IsAtEnd);
}
- [Test]
- public void TestNegativeEnumPackedArray()
- {
- int arraySize = 1 + (10 * 5);
- int msgSize = 1 + 1 + arraySize;
- byte[] bytes = new byte[msgSize];
- CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
- output.WriteTag(8, WireFormat.WireType.LengthDelimited);
- output.WritePackedInt32Array(new RepeatedField<int> { 0, -1, -2, -3, -4, -5 });
-
- Assert.AreEqual(0, output.SpaceLeft);
-
- CodedInputStream input = CodedInputStream.CreateInstance(bytes);
- uint tag;
- Assert.IsTrue(input.ReadTag(out tag));
-
- RepeatedField<TestNegEnum> values = new RepeatedField<TestNegEnum>();
- input.ReadEnumArray(values);
-
- Assert.AreEqual(6, values.Count);
- Assert.AreEqual(TestNegEnum.None, values[0]);
- Assert.AreEqual(TestNegEnum.Value, values[2]);
- // TODO(jonskeet): Test unknown value preservation
- }
-
- [Test]
- public void TestNegativeEnumArray()
- {
- int arraySize = 1 + 1 + (11 * 5);
- int msgSize = arraySize;
- byte[] bytes = new byte[msgSize];
- CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
- output.WriteInt32Array(8, new RepeatedField<int> { 0, -1, -2, -3, -4, -5 });
-
- Assert.AreEqual(0, output.SpaceLeft);
-
- CodedInputStream input = CodedInputStream.CreateInstance(bytes);
- uint tag;
- Assert.IsTrue(input.ReadTag(out tag));
-
- RepeatedField<TestNegEnum> values = new RepeatedField<TestNegEnum>();
- input.ReadEnumArray(values);
-
- Assert.AreEqual(6, values.Count);
- Assert.AreEqual(TestNegEnum.None, values[0]);
- Assert.AreEqual(TestNegEnum.Value, values[2]);
- // TODO(jonskeet): Test unknown value preservation
- }
-
//Issue 71: CodedInputStream.ReadBytes go to slow path unnecessarily
[Test]
public void TestSlowPathAvoidance()
diff --git a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs index 223374e0..ab5dcbd6 100644 --- a/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs +++ b/csharp/src/ProtocolBuffers.Test/CodedOutputStreamTest.cs @@ -35,9 +35,8 @@ #endregion
using System;
-using System.Collections.Generic;
using System.IO;
-using Google.Protobuf.Collections;
+using Google.Protobuf.TestProtos;
using NUnit.Framework;
namespace Google.Protobuf
@@ -195,42 +194,24 @@ namespace Google.Protobuf 0x9abcdef012345678UL);
}
- /*
[Test]
- public void WriteWholeMessage()
+ public void WriteWholeMessage_VaryingBlockSizes()
{
- TestAllTypes message = TestUtil.GetAllSet();
+ TestAllTypes message = GeneratedMessageTest.GetSampleMessage();
byte[] rawBytes = message.ToByteArray();
- TestUtil.AssertEqualBytes(TestUtil.GoldenMessage.ToByteArray(), rawBytes);
// Try different block sizes.
for (int blockSize = 1; blockSize < 256; blockSize *= 2)
{
MemoryStream rawOutput = new MemoryStream();
- CodedOutputStream output =
- CodedOutputStream.CreateInstance(rawOutput, blockSize);
+ CodedOutputStream output = CodedOutputStream.CreateInstance(rawOutput, blockSize);
message.WriteTo(output);
output.Flush();
- TestUtil.AssertEqualBytes(rawBytes, rawOutput.ToArray());
+ Assert.AreEqual(rawBytes, rawOutput.ToArray());
}
}
-
- /// <summary>
- /// Tests writing a whole message with every packed field type. Ensures the
- /// wire format of packed fields is compatible with C++.
- /// </summary>
- [Test]
- public void WriteWholePackedFieldsMessage()
- {
- TestPackedTypes message = TestUtil.GetPackedSet();
-
- byte[] rawBytes = message.ToByteArray();
- TestUtil.AssertEqualBytes(TestUtil.GetGoldenPackedFieldsMessage().ToByteArray(),
- rawBytes);
- }
- */
-
+
[Test]
public void EncodeZigZag32()
{
@@ -296,66 +277,16 @@ namespace Google.Protobuf public void TestNegativeEnumNoTag()
{
Assert.AreEqual(10, CodedOutputStream.ComputeInt32Size(-2));
- Assert.AreEqual(10, CodedOutputStream.ComputeEnumSize((int) TestNegEnum.Value));
+ Assert.AreEqual(10, CodedOutputStream.ComputeEnumSize((int) SampleEnum.NegativeValue));
byte[] bytes = new byte[10];
CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
- output.WriteEnum((int) TestNegEnum.Value);
+ output.WriteEnum((int) SampleEnum.NegativeValue);
Assert.AreEqual(0, output.SpaceLeft);
Assert.AreEqual("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes));
}
- enum TestNegEnum { None = 0, Value = -2 }
-
- [Test]
- public void TestNegativeEnumArrayPacked()
- {
- int arraySize = 1 + (10 * 5);
- int msgSize = 1 + 1 + arraySize;
- byte[] bytes = new byte[msgSize];
- CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
- output.WriteTag(8, WireFormat.WireType.LengthDelimited);
- output.WritePackedEnumArray(new RepeatedField<TestNegEnum> {
- 0, (TestNegEnum) (-1), TestNegEnum.Value, (TestNegEnum) (-3), (TestNegEnum) (-4), (TestNegEnum) (-5) });
-
- Assert.AreEqual(0, output.SpaceLeft);
-
- CodedInputStream input = CodedInputStream.CreateInstance(bytes);
- uint tag;
- Assert.IsTrue(input.ReadTag(out tag));
-
- List<int> values = new List<int>();
- input.ReadInt32Array(values);
-
- Assert.AreEqual(6, values.Count);
- for (int i = 0; i > -6; i--)
- Assert.AreEqual(i, values[Math.Abs(i)]);
- }
-
- [Test]
- public void TestNegativeEnumArray()
- {
- int arraySize = 1 + 1 + (11 * 5);
- int msgSize = arraySize;
- byte[] bytes = new byte[msgSize];
- CodedOutputStream output = CodedOutputStream.CreateInstance(bytes);
- output.WriteEnumArray(8, new RepeatedField<TestNegEnum> {
- 0, (TestNegEnum) (-1), TestNegEnum.Value, (TestNegEnum) (-3), (TestNegEnum) (-4), (TestNegEnum) (-5) });
- Assert.AreEqual(0, output.SpaceLeft);
-
- CodedInputStream input = CodedInputStream.CreateInstance(bytes);
- uint tag;
- Assert.IsTrue(input.ReadTag(out tag));
-
- List<int> values = new List<int>();
- input.ReadInt32Array(values);
-
- Assert.AreEqual(6, values.Count);
- for (int i = 0; i > -6; i--)
- Assert.AreEqual(i, values[Math.Abs(i)]);
- }
-
[Test]
public void TestCodedInputOutputPosition()
{
@@ -405,7 +336,7 @@ namespace Google.Protobuf Assert.AreEqual(130, cout.Position);
cout.Flush();
}
- //Now test Input stream:
+ // Now test Input stream:
{
CodedInputStream cin = CodedInputStream.CreateInstance(new MemoryStream(bytes), new byte[50]);
uint tag;
@@ -418,8 +349,8 @@ namespace Google.Protobuf //Field 2:
Assert.IsTrue(cin.ReadTag(out tag) && tag >> 3 == 2);
Assert.AreEqual(4, cin.Position);
- uint childlen = cin.ReadRawVarint32();
- Assert.AreEqual(120u, childlen);
+ int childlen = cin.ReadLength();
+ Assert.AreEqual(120, childlen);
Assert.AreEqual(5, cin.Position);
int oldlimit = cin.PushLimit((int)childlen);
Assert.AreEqual(5, cin.Position);
diff --git a/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs b/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs index 29945c36..988801b7 100644 --- a/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs +++ b/csharp/src/ProtocolBuffers.Test/Collections/RepeatedFieldTest.cs @@ -1,5 +1,39 @@ -using System; +#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.IO; +using System.Linq; using Google.Protobuf.TestProtos; using NUnit.Framework; @@ -89,5 +123,260 @@ namespace Google.Protobuf.Collections var clone = list.Clone(); clone[0] = 1; } + + [Test] + public void AddEntriesFrom_PackedInt32() + { + uint packedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); + var stream = new MemoryStream(); + var output = CodedOutputStream.CreateInstance(stream); + var length = CodedOutputStream.ComputeInt32Size(10) + + CodedOutputStream.ComputeInt32Size(999) + + CodedOutputStream.ComputeInt32Size(-1000); + output.WriteTag(packedTag); + output.WriteRawVarint32((uint) length); + output.WriteInt32(10); + output.WriteInt32(999); + output.WriteInt32(-1000); + output.Flush(); + stream.Position = 0; + + // Deliberately "expecting" a non-packed tag, but we detect that the data is + // actually packed. + uint nonPackedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); + var field = new RepeatedField<int>(); + var input = CodedInputStream.CreateInstance(stream); + input.AssertNextTag(packedTag); + field.AddEntriesFrom(input, FieldCodec.ForInt32(nonPackedTag)); + CollectionAssert.AreEqual(new[] { 10, 999, -1000 }, field); + Assert.IsTrue(input.IsAtEnd); + } + + [Test] + public void AddEntriesFrom_NonPackedInt32() + { + uint nonPackedTag = WireFormat.MakeTag(10, WireFormat.WireType.Varint); + var stream = new MemoryStream(); + var output = CodedOutputStream.CreateInstance(stream); + output.WriteTag(nonPackedTag); + output.WriteInt32(10); + output.WriteTag(nonPackedTag); + output.WriteInt32(999); + output.WriteTag(nonPackedTag); + output.WriteInt32(-1000); // Just for variety... + output.Flush(); + stream.Position = 0; + + // Deliberately "expecting" a packed tag, but we detect that the data is + // actually not packed. + uint packedTag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); + var field = new RepeatedField<int>(); + var input = CodedInputStream.CreateInstance(stream); + input.AssertNextTag(nonPackedTag); + field.AddEntriesFrom(input, FieldCodec.ForInt32(packedTag)); + CollectionAssert.AreEqual(new[] { 10, 999, -1000 }, field); + Assert.IsTrue(input.IsAtEnd); + } + + [Test] + public void AddEntriesFrom_String() + { + uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); + var stream = new MemoryStream(); + var output = CodedOutputStream.CreateInstance(stream); + output.WriteTag(tag); + output.WriteString("Foo"); + output.WriteTag(tag); + output.WriteString(""); + output.WriteTag(tag); + output.WriteString("Bar"); + output.Flush(); + stream.Position = 0; + + var field = new RepeatedField<string>(); + var input = CodedInputStream.CreateInstance(stream); + input.AssertNextTag(tag); + field.AddEntriesFrom(input, FieldCodec.ForString(tag)); + CollectionAssert.AreEqual(new[] { "Foo", "", "Bar" }, field); + Assert.IsTrue(input.IsAtEnd); + } + + [Test] + public void AddEntriesFrom_Message() + { + var message1 = new ForeignMessage { C = 2000 }; + var message2 = new ForeignMessage { C = -250 }; + + uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); + var stream = new MemoryStream(); + var output = CodedOutputStream.CreateInstance(stream); + output.WriteTag(tag); + output.WriteMessage(message1); + output.WriteTag(tag); + output.WriteMessage(message2); + output.Flush(); + stream.Position = 0; + + var field = new RepeatedField<ForeignMessage>(); + var input = CodedInputStream.CreateInstance(stream); + input.AssertNextTag(tag); + field.AddEntriesFrom(input, FieldCodec.ForMessage(tag, ForeignMessage.Parser)); + CollectionAssert.AreEqual(new[] { message1, message2}, field); + Assert.IsTrue(input.IsAtEnd); + } + + [Test] + public void WriteTo_PackedInt32() + { + uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); + var field = new RepeatedField<int> { 10, 1000, 1000000 }; + var stream = new MemoryStream(); + var output = CodedOutputStream.CreateInstance(stream); + field.WriteTo(output, FieldCodec.ForInt32(tag)); + output.Flush(); + stream.Position = 0; + + var input = CodedInputStream.CreateInstance(stream); + input.AssertNextTag(tag); + var length = input.ReadLength(); + Assert.AreEqual(10, input.ReadInt32()); + Assert.AreEqual(1000, input.ReadInt32()); + Assert.AreEqual(1000000, input.ReadInt32()); + Assert.IsTrue(input.IsAtEnd); + Assert.AreEqual(1 + CodedOutputStream.ComputeLengthSize(length) + length, stream.Length); + } + + [Test] + public void WriteTo_NonPackedInt32() + { + uint tag = WireFormat.MakeTag(10, WireFormat.WireType.Varint); + var field = new RepeatedField<int> { 10, 1000, 1000000}; + var stream = new MemoryStream(); + var output = CodedOutputStream.CreateInstance(stream); + field.WriteTo(output, FieldCodec.ForInt32(tag)); + output.Flush(); + stream.Position = 0; + + var input = CodedInputStream.CreateInstance(stream); + input.AssertNextTag(tag); + Assert.AreEqual(10, input.ReadInt32()); + input.AssertNextTag(tag); + Assert.AreEqual(1000, input.ReadInt32()); + input.AssertNextTag(tag); + Assert.AreEqual(1000000, input.ReadInt32()); + Assert.IsTrue(input.IsAtEnd); + } + + [Test] + public void WriteTo_String() + { + uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); + var field = new RepeatedField<string> { "Foo", "", "Bar" }; + var stream = new MemoryStream(); + var output = CodedOutputStream.CreateInstance(stream); + field.WriteTo(output, FieldCodec.ForString(tag)); + output.Flush(); + stream.Position = 0; + + var input = CodedInputStream.CreateInstance(stream); + input.AssertNextTag(tag); + Assert.AreEqual("Foo", input.ReadString()); + input.AssertNextTag(tag); + Assert.AreEqual("", input.ReadString()); + input.AssertNextTag(tag); + Assert.AreEqual("Bar", input.ReadString()); + Assert.IsTrue(input.IsAtEnd); + } + + [Test] + public void WriteTo_Message() + { + var message1 = new ForeignMessage { C = 20 }; + var message2 = new ForeignMessage { C = 25 }; + uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited); + var field = new RepeatedField<ForeignMessage> { message1, message2 }; + var stream = new MemoryStream(); + var output = CodedOutputStream.CreateInstance(stream); + field.WriteTo(output, FieldCodec.ForMessage(tag, ForeignMessage.Parser)); + output.Flush(); + stream.Position = 0; + + var input = CodedInputStream.CreateInstance(stream); + input.AssertNextTag(tag); + Assert.AreEqual(message1, input.ReadMessage(ForeignMessage.Parser)); + input.AssertNextTag(tag); + Assert.AreEqual(message2, input.ReadMessage(ForeignMessage.Parser)); + Assert.IsTrue(input.IsAtEnd); + } + + + [Test] + public void TestNegativeEnumArray() + { + int arraySize = 1 + 1 + (11 * 5); + int msgSize = arraySize; + byte[] bytes = new byte[msgSize]; + CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); + uint tag = WireFormat.MakeTag(8, WireFormat.WireType.Varint); + for (int i = 0; i >= -5; i--) + { + output.WriteTag(tag); + output.WriteEnum(i); + } + + Assert.AreEqual(0, output.SpaceLeft); + + CodedInputStream input = CodedInputStream.CreateInstance(bytes); + Assert.IsTrue(input.ReadTag(out tag)); + + RepeatedField<SampleEnum> values = new RepeatedField<SampleEnum>(); + values.AddEntriesFrom(input, FieldCodec.ForEnum(tag, x => (int)x, x => (SampleEnum)x)); + + Assert.AreEqual(6, values.Count); + Assert.AreEqual(SampleEnum.None, values[0]); + Assert.AreEqual(((SampleEnum)(-1)), values[1]); + Assert.AreEqual(SampleEnum.NegativeValue, values[2]); + Assert.AreEqual(((SampleEnum)(-3)), values[3]); + Assert.AreEqual(((SampleEnum)(-4)), values[4]); + Assert.AreEqual(((SampleEnum)(-5)), values[5]); + } + + + [Test] + public void TestNegativeEnumPackedArray() + { + int arraySize = 1 + (10 * 5); + int msgSize = 1 + 1 + arraySize; + byte[] bytes = new byte[msgSize]; + CodedOutputStream output = CodedOutputStream.CreateInstance(bytes); + // Length-delimited to show we want the packed representation + uint tag = WireFormat.MakeTag(8, WireFormat.WireType.LengthDelimited); + output.WriteTag(tag); + int size = 0; + for (int i = 0; i >= -5; i--) + { + size += CodedOutputStream.ComputeEnumSize(i); + } + output.WriteRawVarint32((uint)size); + for (int i = 0; i >= -5; i--) + { + output.WriteEnum(i); + } + Assert.AreEqual(0, output.SpaceLeft); + + CodedInputStream input = CodedInputStream.CreateInstance(bytes); + Assert.IsTrue(input.ReadTag(out tag)); + + RepeatedField<SampleEnum> values = new RepeatedField<SampleEnum>(); + values.AddEntriesFrom(input, FieldCodec.ForEnum(tag, x => (int)x, x => (SampleEnum)x)); + + Assert.AreEqual(6, values.Count); + Assert.AreEqual(SampleEnum.None, values[0]); + Assert.AreEqual(((SampleEnum)(-1)), values[1]); + Assert.AreEqual(SampleEnum.NegativeValue, values[2]); + Assert.AreEqual(((SampleEnum)(-3)), values[3]); + Assert.AreEqual(((SampleEnum)(-4)), values[4]); + Assert.AreEqual(((SampleEnum)(-5)), values[5]); + } } } diff --git a/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs b/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs index e2b8e3ef..a14040d1 100644 --- a/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs +++ b/csharp/src/ProtocolBuffers.Test/FieldCodecTest.cs @@ -63,15 +63,21 @@ namespace Google.Protobuf }; [Test, TestCaseSource("Codecs")] - public void RoundTrip(ICodecTestData codec) + public void RoundTripWithTag(ICodecTestData codec) { - codec.TestRoundTrip(); + codec.TestRoundTripWithTag(); + } + + [Test, TestCaseSource("Codecs")] + public void RoundTripRaw(ICodecTestData codec) + { + codec.TestRoundTripRaw(); } [Test, TestCaseSource("Codecs")] public void CalculateSize(ICodecTestData codec) { - codec.TestCalculateSize(); + codec.TestCalculateSizeWithTag(); } [Test, TestCaseSource("Codecs")] @@ -82,8 +88,9 @@ namespace Google.Protobuf public interface ICodecTestData { - void TestRoundTrip(); - void TestCalculateSize(); + void TestRoundTripRaw(); + void TestRoundTripWithTag(); + void TestCalculateSizeWithTag(); void TestDefaultValue(); } @@ -100,45 +107,67 @@ namespace Google.Protobuf this.name = name; } - public void TestRoundTrip() + public void TestRoundTripRaw() { var stream = new MemoryStream(); var codedOutput = CodedOutputStream.CreateInstance(stream); - codec.Write(codedOutput, sampleValue); + codec.ValueWriter(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.ValueReader(codedInput)); + Assert.IsTrue(codedInput.IsAtEnd); + } + + public void TestRoundTripWithTag() + { + var stream = new MemoryStream(); + var codedOutput = CodedOutputStream.CreateInstance(stream); + codec.WriteTagAndValue(codedOutput, sampleValue); + codedOutput.Flush(); + stream.Position = 0; + var codedInput = CodedInputStream.CreateInstance(stream); + codedInput.AssertNextTag(codec.Tag); Assert.AreEqual(sampleValue, codec.Read(codedInput)); Assert.IsTrue(codedInput.IsAtEnd); } - public void TestCalculateSize() + public void TestCalculateSizeWithTag() { var stream = new MemoryStream(); var codedOutput = CodedOutputStream.CreateInstance(stream); - codec.Write(codedOutput, sampleValue); + codec.WriteTagAndValue(codedOutput, sampleValue); codedOutput.Flush(); - Assert.AreEqual(stream.Position, codec.CalculateSize(sampleValue)); + Assert.AreEqual(stream.Position, codec.CalculateSizeWithTag(sampleValue)); } public void TestDefaultValue() { + // WriteTagAndValue ignores default values var stream = new MemoryStream(); var codedOutput = CodedOutputStream.CreateInstance(stream); - codec.Write(codedOutput, codec.DefaultValue); + codec.WriteTagAndValue(codedOutput, codec.DefaultValue); codedOutput.Flush(); Assert.AreEqual(0, stream.Position); - Assert.AreEqual(0, codec.CalculateSize(codec.DefaultValue)); + Assert.AreEqual(0, codec.CalculateSizeWithTag(codec.DefaultValue)); if (typeof(T).IsValueType) { Assert.AreEqual(default(T), codec.DefaultValue); } - } - public string Description { get { return name; } } + // The plain ValueWriter/ValueReader delegates don't. + if (codec.DefaultValue != null) // This part isn't appropriate for message types. + { + codedOutput = CodedOutputStream.CreateInstance(stream); + codec.ValueWriter(codedOutput, codec.DefaultValue); + codedOutput.Flush(); + Assert.AreNotEqual(0, stream.Position); + Assert.AreEqual(stream.Position, codec.ValueSizeCalculator(codec.DefaultValue)); + stream.Position = 0; + var codedInput = CodedInputStream.CreateInstance(stream); + Assert.AreEqual(codec.DefaultValue, codec.ValueReader(codedInput)); + } + } public override string ToString() { diff --git a/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs index f8668662..a094e46b 100644 --- a/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs +++ b/csharp/src/ProtocolBuffers.Test/GeneratedMessageTest.cs @@ -10,6 +10,61 @@ namespace Google.Protobuf /// </summary>
public class GeneratedMessageTest
{
+ /// <summary>
+ /// Returns a sample TestAllTypes with all fields populated
+ /// </summary>
+ public static TestAllTypes GetSampleMessage()
+ {
+ return new TestAllTypes
+ {
+ SingleBool = true,
+ SingleBytes = ByteString.CopyFrom(1, 2, 3, 4),
+ SingleDouble = 23.5,
+ SingleFixed32 = 23,
+ SingleFixed64 = 1234567890123,
+ SingleFloat = 12.25f,
+ SingleForeignEnum = ForeignEnum.FOREIGN_BAR,
+ SingleForeignMessage = new ForeignMessage { C = 10 },
+ SingleImportEnum = ImportEnum.IMPORT_BAZ,
+ SingleImportMessage = new ImportMessage { D = 20 },
+ SingleInt32 = 100,
+ SingleInt64 = 3210987654321,
+ SingleNestedEnum = TestAllTypes.Types.NestedEnum.FOO,
+ SingleNestedMessage = new TestAllTypes.Types.NestedMessage { Bb = 35 },
+ SinglePublicImportMessage = new PublicImportMessage { E = 54 },
+ SingleSfixed32 = -123,
+ SingleSfixed64 = -12345678901234,
+ SingleSint32 = -456,
+ SingleSint64 = -12345678901235,
+ SingleString = "test",
+ SingleUint32 = uint.MaxValue,
+ SingleUint64 = ulong.MaxValue,
+ RepeatedBool = { true, false },
+ RepeatedBytes = { ByteString.CopyFrom(1, 2, 3, 4), ByteString.CopyFrom(5, 6), ByteString.CopyFrom(new byte[1000]) },
+ RepeatedDouble = { -12.25, 23.5 },
+ RepeatedFixed32 = { uint.MaxValue, 23 },
+ RepeatedFixed64 = { ulong.MaxValue, 1234567890123 },
+ RepeatedFloat = { 100f, 12.25f },
+ RepeatedForeignEnum = { ForeignEnum.FOREIGN_FOO, ForeignEnum.FOREIGN_BAR },
+ RepeatedForeignMessage = { new ForeignMessage(), new ForeignMessage { C = 10 } },
+ RepeatedImportEnum = { ImportEnum.IMPORT_BAZ, ImportEnum.IMPORT_ENUM_UNSPECIFIED },
+ RepeatedImportMessage = { new ImportMessage { D = 20 }, new ImportMessage { D = 25 } },
+ RepeatedInt32 = { 100, 200 },
+ RepeatedInt64 = { 3210987654321, long.MaxValue },
+ RepeatedNestedEnum = { TestAllTypes.Types.NestedEnum.FOO, TestAllTypes.Types.NestedEnum.NEG },
+ RepeatedNestedMessage = { new TestAllTypes.Types.NestedMessage { Bb = 35 }, new TestAllTypes.Types.NestedMessage { Bb = 10 } },
+ RepeatedPublicImportMessage = { new PublicImportMessage { E = 54 }, new PublicImportMessage { E = -1 } },
+ RepeatedSfixed32 = { -123, 123 },
+ RepeatedSfixed64 = { -12345678901234, 12345678901234 },
+ RepeatedSint32 = { -456, 100 },
+ RepeatedSint64 = { -12345678901235, 123 },
+ RepeatedString = { "foo", "bar" },
+ RepeatedUint32 = { uint.MaxValue, uint.MinValue },
+ RepeatedUint64 = { ulong.MaxValue, uint.MinValue },
+ OneofString = "Oneof string"
+ };
+ }
+
[Test]
public void EmptyMessageFieldDistinctFromMissingMessageField()
{
@@ -485,5 +540,83 @@ namespace Google.Protobuf Assert.Throws<InvalidOperationException>(() => frozen.RepeatedDouble.Add(0.0));
Assert.Throws<InvalidOperationException>(() => frozen.RepeatedNestedMessage.Add(new TestAllTypes.Types.NestedMessage()));
}
+
+ [Test]
+ public void OneofProperties()
+ {
+ // Switch the oneof case between each of the different options, and check everything behaves
+ // as expected in each case.
+ var message = new TestAllTypes();
+ Assert.AreEqual("", message.OneofString);
+ Assert.AreEqual(0, message.OneofUint32);
+ Assert.AreEqual(ByteString.Empty, message.OneofBytes);
+ Assert.IsNull(message.OneofNestedMessage);
+ Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.None, message.OneofFieldCase);
+
+ message.OneofString = "sample";
+ Assert.AreEqual("sample", message.OneofString);
+ Assert.AreEqual(0, message.OneofUint32);
+ Assert.AreEqual(ByteString.Empty, message.OneofBytes);
+ Assert.IsNull(message.OneofNestedMessage);
+ Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofString, message.OneofFieldCase);
+
+ var bytes = ByteString.CopyFrom(1, 2, 3);
+ message.OneofBytes = bytes;
+ Assert.AreEqual("", message.OneofString);
+ Assert.AreEqual(0, message.OneofUint32);
+ Assert.AreEqual(bytes, message.OneofBytes);
+ Assert.IsNull(message.OneofNestedMessage);
+ Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofBytes, message.OneofFieldCase);
+
+ message.OneofUint32 = 20;
+ Assert.AreEqual("", message.OneofString);
+ Assert.AreEqual(20, message.OneofUint32);
+ Assert.AreEqual(ByteString.Empty, message.OneofBytes);
+ Assert.IsNull(message.OneofNestedMessage);
+ Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofUint32, message.OneofFieldCase);
+
+ var nestedMessage = new TestAllTypes.Types.NestedMessage { Bb = 25 };
+ message.OneofNestedMessage = nestedMessage;
+ Assert.AreEqual("", message.OneofString);
+ Assert.AreEqual(0, message.OneofUint32);
+ Assert.AreEqual(ByteString.Empty, message.OneofBytes);
+ Assert.AreEqual(nestedMessage, message.OneofNestedMessage);
+ Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofNestedMessage, message.OneofFieldCase);
+
+ message.ClearOneofField();
+ Assert.AreEqual("", message.OneofString);
+ Assert.AreEqual(0, message.OneofUint32);
+ Assert.AreEqual(ByteString.Empty, message.OneofBytes);
+ Assert.IsNull(message.OneofNestedMessage);
+ Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.None, message.OneofFieldCase);
+ }
+
+ [Test]
+ public void OneofSerialization_NonDefaultValue()
+ {
+ var message = new TestAllTypes();
+ message.OneofString = "this would take a bit of space";
+ message.OneofUint32 = 10;
+ var bytes = message.ToByteArray();
+ Assert.AreEqual(3, bytes.Length); // 2 bytes for the tag + 1 for the value - no string!
+
+ var message2 = TestAllTypes.Parser.ParseFrom(bytes);
+ Assert.AreEqual(message, message2);
+ Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofUint32, message2.OneofFieldCase);
+ }
+
+ [Test]
+ public void OneofSerialization_DefaultValue()
+ {
+ var message = new TestAllTypes();
+ message.OneofString = "this would take a bit of space";
+ message.OneofUint32 = 0; // This is the default value for UInt32; normally wouldn't be serialized
+ var bytes = message.ToByteArray();
+ Assert.AreEqual(3, bytes.Length); // 2 bytes for the tag + 1 for the value - it's still serialized
+
+ var message2 = TestAllTypes.Parser.ParseFrom(bytes);
+ Assert.AreEqual(message, message2);
+ Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofUint32, message2.OneofFieldCase);
+ }
}
}
diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj index 80b504aa..ae7d7575 100644 --- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj +++ b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj @@ -72,6 +72,7 @@ </ItemGroup>
<ItemGroup>
<Compile Include="ByteStringTest.cs" />
+ <Compile Include="CodedInputStreamExtensions.cs" />
<Compile Include="CodedInputStreamTest.cs" />
<Compile Include="CodedOutputStreamTest.cs" />
<Compile Include="EqualityTester.cs" />
@@ -79,6 +80,7 @@ <Compile Include="GeneratedMessageTest.cs" />
<Compile Include="Collections\MapFieldTest.cs" />
<Compile Include="Collections\RepeatedFieldTest.cs" />
+ <Compile Include="SampleEnum.cs" />
<Compile Include="TestProtos\MapUnittestProto3.cs" />
<Compile Include="TestProtos\UnittestImportProto3.cs" />
<Compile Include="TestProtos\UnittestImportPublicProto3.cs" />
diff --git a/csharp/src/ProtocolBuffers.Test/SampleEnum.cs b/csharp/src/ProtocolBuffers.Test/SampleEnum.cs new file mode 100644 index 00000000..001f9b08 --- /dev/null +++ b/csharp/src/ProtocolBuffers.Test/SampleEnum.cs @@ -0,0 +1,42 @@ +#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 + +namespace Google.Protobuf +{ + // Just a sample enum with positive and negative values to be used in tests. + internal enum SampleEnum + { + NegativeValue = -2, + None = 0, + PositiveValue = 3 + } +}
\ No newline at end of file diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs index 19de87de..16bdb3f2 100644 --- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs +++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs @@ -422,13 +422,15 @@ namespace UnitTest.Issues.TestProtos { } public const int ValuesFieldNumber = 2; - private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> values_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>(); + private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.NegativeEnum> _repeated_values_codec + = pb::FieldCodec.ForEnum(16, x => (int) x, x => (global::UnitTest.Issues.TestProtos.NegativeEnum) x);private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> values_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>(); public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> Values { get { return values_; } } public const int PackedValuesFieldNumber = 3; - private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> packedValues_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>(); + private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.NegativeEnum> _repeated_packedValues_codec + = pb::FieldCodec.ForEnum(26, x => (int) x, x => (global::UnitTest.Issues.TestProtos.NegativeEnum) x);private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> packedValues_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>(); public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> PackedValues { get { return packedValues_; } } @@ -463,13 +465,8 @@ namespace UnitTest.Issues.TestProtos { output.WriteRawTag(8); output.WriteEnum((int) Value); } - if (values_.Count > 0) { - output.WriteEnumArray(2, values_); - } - if (packedValues_.Count > 0) { - output.WriteRawTag(26); - output.WritePackedEnumArray(packedValues_); - } + values_.WriteTo(output, _repeated_values_codec); + packedValues_.WriteTo(output, _repeated_packedValues_codec); } public int CalculateSize() { @@ -477,22 +474,8 @@ namespace UnitTest.Issues.TestProtos { if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO) { size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Value); } - if (values_.Count > 0) { - int dataSize = 0; - foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in values_) { - dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); - } - size += dataSize; - size += 1 * values_.Count; - } - if (packedValues_.Count > 0) { - int dataSize = 0; - foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in packedValues_) { - dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); - } - size += dataSize; - size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); - } + size += values_.CalculateSize(_repeated_values_codec); + size += packedValues_.CalculateSize(_repeated_packedValues_codec); return size; } @@ -524,12 +507,12 @@ namespace UnitTest.Issues.TestProtos { } case 18: case 16: { - input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(values_); + values_.AddEntriesFrom(input, _repeated_values_codec); break; } case 26: case 24: { - input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(packedValues_); + packedValues_.AddEntriesFrom(input, _repeated_packedValues_codec); break; } } @@ -678,6 +661,8 @@ namespace UnitTest.Issues.TestProtos { } public const int PrimitiveArrayFieldNumber = 2; + private static readonly pb::FieldCodec<int> _repeated_primitiveArray_codec + = pb::FieldCodec.ForInt32(18); private readonly pbc::RepeatedField<int> primitiveArray_ = new pbc::RepeatedField<int>(); [global::System.ObsoleteAttribute()] public pbc::RepeatedField<int> PrimitiveArray { @@ -696,6 +681,8 @@ namespace UnitTest.Issues.TestProtos { } public const int MessageArrayFieldNumber = 4; + private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.DeprecatedChild> _repeated_messageArray_codec + = pb::FieldCodec.ForMessage(34, global::UnitTest.Issues.TestProtos.DeprecatedChild.Parser); private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild> messageArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild>(); [global::System.ObsoleteAttribute()] public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild> MessageArray { @@ -714,7 +701,8 @@ namespace UnitTest.Issues.TestProtos { } public const int EnumArrayFieldNumber = 6; - private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> enumArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum>(); + private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.DeprecatedEnum> _repeated_enumArray_codec + = pb::FieldCodec.ForEnum(50, x => (int) x, x => (global::UnitTest.Issues.TestProtos.DeprecatedEnum) x);private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> enumArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum>(); [global::System.ObsoleteAttribute()] public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> EnumArray { get { return enumArray_; } @@ -756,25 +744,17 @@ namespace UnitTest.Issues.TestProtos { output.WriteRawTag(8); output.WriteInt32(PrimitiveValue); } - if (primitiveArray_.Count > 0) { - output.WriteRawTag(18); - output.WritePackedInt32Array(primitiveArray_); - } + primitiveArray_.WriteTo(output, _repeated_primitiveArray_codec); if (messageValue_ != null) { output.WriteRawTag(26); output.WriteMessage(MessageValue); } - if (messageArray_.Count > 0) { - output.WriteMessageArray(4, messageArray_); - } + messageArray_.WriteTo(output, _repeated_messageArray_codec); if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) { output.WriteRawTag(40); output.WriteEnum((int) EnumValue); } - if (enumArray_.Count > 0) { - output.WriteRawTag(50); - output.WritePackedEnumArray(enumArray_); - } + enumArray_.WriteTo(output, _repeated_enumArray_codec); } public int CalculateSize() { @@ -782,34 +762,15 @@ namespace UnitTest.Issues.TestProtos { if (PrimitiveValue != 0) { size += 1 + pb::CodedOutputStream.ComputeInt32Size(PrimitiveValue); } - if (primitiveArray_.Count > 0) { - int dataSize = 0; - foreach (int element in primitiveArray_) { - dataSize += pb::CodedOutputStream.ComputeInt32Size(element); - } - size += dataSize; - size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } + size += primitiveArray_.CalculateSize(_repeated_primitiveArray_codec); if (messageValue_ != null) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(MessageValue); } - if (messageArray_.Count > 0) { - foreach (global::UnitTest.Issues.TestProtos.DeprecatedChild element in messageArray_) { - size += pb::CodedOutputStream.ComputeMessageSize(element); - } - size += 1 * messageArray_.Count; - } + size += messageArray_.CalculateSize(_repeated_messageArray_codec); if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) { size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) EnumValue); } - if (enumArray_.Count > 0) { - int dataSize = 0; - foreach (global::UnitTest.Issues.TestProtos.DeprecatedEnum element in enumArray_) { - dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); - } - size += dataSize; - size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); - } + size += enumArray_.CalculateSize(_repeated_enumArray_codec); return size; } @@ -851,7 +812,7 @@ namespace UnitTest.Issues.TestProtos { } case 18: case 16: { - input.ReadInt32Array(primitiveArray_); + primitiveArray_.AddEntriesFrom(input, _repeated_primitiveArray_codec); break; } case 26: { @@ -862,7 +823,7 @@ namespace UnitTest.Issues.TestProtos { break; } case 34: { - input.ReadMessageArray(messageArray_, global::UnitTest.Issues.TestProtos.DeprecatedChild.Parser); + messageArray_.AddEntriesFrom(input, _repeated_messageArray_codec); break; } case 40: { @@ -871,7 +832,7 @@ namespace UnitTest.Issues.TestProtos { } case 50: case 48: { - input.ReadEnumArray<global::UnitTest.Issues.TestProtos.DeprecatedEnum>(enumArray_); + enumArray_.AddEntriesFrom(input, _repeated_enumArray_codec); break; } } diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs index 1ae2d9a9..ea486fcc 100644 --- a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs +++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs @@ -742,132 +742,173 @@ namespace Google.Protobuf.TestProtos { } public const int RepeatedInt32FieldNumber = 31; + private static readonly pb::FieldCodec<int> _repeated_repeatedInt32_codec + = pb::FieldCodec.ForInt32(250); private readonly pbc::RepeatedField<int> repeatedInt32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> RepeatedInt32 { get { return repeatedInt32_; } } public const int RepeatedInt64FieldNumber = 32; + private static readonly pb::FieldCodec<long> _repeated_repeatedInt64_codec + = pb::FieldCodec.ForInt64(258); private readonly pbc::RepeatedField<long> repeatedInt64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> RepeatedInt64 { get { return repeatedInt64_; } } public const int RepeatedUint32FieldNumber = 33; + private static readonly pb::FieldCodec<uint> _repeated_repeatedUint32_codec + = pb::FieldCodec.ForUInt32(266); private readonly pbc::RepeatedField<uint> repeatedUint32_ = new pbc::RepeatedField<uint>(); public pbc::RepeatedField<uint> RepeatedUint32 { get { return repeatedUint32_; } } public const int RepeatedUint64FieldNumber = 34; + private static readonly pb::FieldCodec<ulong> _repeated_repeatedUint64_codec + = pb::FieldCodec.ForUInt64(274); private readonly pbc::RepeatedField<ulong> repeatedUint64_ = new pbc::RepeatedField<ulong>(); public pbc::RepeatedField<ulong> RepeatedUint64 { get { return repeatedUint64_; } } public const int RepeatedSint32FieldNumber = 35; + private static readonly pb::FieldCodec<int> _repeated_repeatedSint32_codec + = pb::FieldCodec.ForSInt32(282); private readonly pbc::RepeatedField<int> repeatedSint32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> RepeatedSint32 { get { return repeatedSint32_; } } public const int RepeatedSint64FieldNumber = 36; + private static readonly pb::FieldCodec<long> _repeated_repeatedSint64_codec + = pb::FieldCodec.ForSInt64(290); private readonly pbc::RepeatedField<long> repeatedSint64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> RepeatedSint64 { get { return repeatedSint64_; } } public const int RepeatedFixed32FieldNumber = 37; + private static readonly pb::FieldCodec<uint> _repeated_repeatedFixed32_codec + = pb::FieldCodec.ForFixed32(298); private readonly pbc::RepeatedField<uint> repeatedFixed32_ = new pbc::RepeatedField<uint>(); public pbc::RepeatedField<uint> RepeatedFixed32 { get { return repeatedFixed32_; } } public const int RepeatedFixed64FieldNumber = 38; + private static readonly pb::FieldCodec<ulong> _repeated_repeatedFixed64_codec + = pb::FieldCodec.ForFixed64(306); private readonly pbc::RepeatedField<ulong> repeatedFixed64_ = new pbc::RepeatedField<ulong>(); public pbc::RepeatedField<ulong> RepeatedFixed64 { get { return repeatedFixed64_; } } public const int RepeatedSfixed32FieldNumber = 39; + private static readonly pb::FieldCodec<int> _repeated_repeatedSfixed32_codec + = pb::FieldCodec.ForSFixed32(314); private readonly pbc::RepeatedField<int> repeatedSfixed32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> RepeatedSfixed32 { get { return repeatedSfixed32_; } } public const int RepeatedSfixed64FieldNumber = 40; + private static readonly pb::FieldCodec<long> _repeated_repeatedSfixed64_codec + = pb::FieldCodec.ForSFixed64(322); private readonly pbc::RepeatedField<long> repeatedSfixed64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> RepeatedSfixed64 { get { return repeatedSfixed64_; } } public const int RepeatedFloatFieldNumber = 41; + private static readonly pb::FieldCodec<float> _repeated_repeatedFloat_codec + = pb::FieldCodec.ForFloat(330); private readonly pbc::RepeatedField<float> repeatedFloat_ = new pbc::RepeatedField<float>(); public pbc::RepeatedField<float> RepeatedFloat { get { return repeatedFloat_; } } public const int RepeatedDoubleFieldNumber = 42; + private static readonly pb::FieldCodec<double> _repeated_repeatedDouble_codec + = pb::FieldCodec.ForDouble(338); private readonly pbc::RepeatedField<double> repeatedDouble_ = new pbc::RepeatedField<double>(); public pbc::RepeatedField<double> RepeatedDouble { get { return repeatedDouble_; } } public const int RepeatedBoolFieldNumber = 43; + private static readonly pb::FieldCodec<bool> _repeated_repeatedBool_codec + = pb::FieldCodec.ForBool(346); private readonly pbc::RepeatedField<bool> repeatedBool_ = new pbc::RepeatedField<bool>(); public pbc::RepeatedField<bool> RepeatedBool { get { return repeatedBool_; } } public const int RepeatedStringFieldNumber = 44; + private static readonly pb::FieldCodec<string> _repeated_repeatedString_codec + = pb::FieldCodec.ForString(354); private readonly pbc::RepeatedField<string> repeatedString_ = new pbc::RepeatedField<string>(); public pbc::RepeatedField<string> RepeatedString { get { return repeatedString_; } } public const int RepeatedBytesFieldNumber = 45; + private static readonly pb::FieldCodec<pb::ByteString> _repeated_repeatedBytes_codec + = pb::FieldCodec.ForBytes(362); private readonly pbc::RepeatedField<pb::ByteString> repeatedBytes_ = new pbc::RepeatedField<pb::ByteString>(); public pbc::RepeatedField<pb::ByteString> RepeatedBytes { get { return repeatedBytes_; } } public const int RepeatedNestedMessageFieldNumber = 48; + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage> _repeated_repeatedNestedMessage_codec + = pb::FieldCodec.ForMessage(386, global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage.Parser); private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage> repeatedNestedMessage_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage> RepeatedNestedMessage { get { return repeatedNestedMessage_; } } public const int RepeatedForeignMessageFieldNumber = 49; + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignMessage> _repeated_repeatedForeignMessage_codec + = pb::FieldCodec.ForMessage(394, global::Google.Protobuf.TestProtos.ForeignMessage.Parser); private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> repeatedForeignMessage_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> RepeatedForeignMessage { get { return repeatedForeignMessage_; } } public const int RepeatedImportMessageFieldNumber = 50; + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ImportMessage> _repeated_repeatedImportMessage_codec + = pb::FieldCodec.ForMessage(402, global::Google.Protobuf.TestProtos.ImportMessage.Parser); private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportMessage> repeatedImportMessage_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportMessage>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportMessage> RepeatedImportMessage { get { return repeatedImportMessage_; } } public const int RepeatedNestedEnumFieldNumber = 51; - private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum> repeatedNestedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum>(); + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum> _repeated_repeatedNestedEnum_codec + = pb::FieldCodec.ForEnum(410, x => (int) x, x => (global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum> repeatedNestedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum> RepeatedNestedEnum { get { return repeatedNestedEnum_; } } public const int RepeatedForeignEnumFieldNumber = 52; - private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> repeatedForeignEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>(); + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignEnum> _repeated_repeatedForeignEnum_codec + = pb::FieldCodec.ForEnum(418, x => (int) x, x => (global::Google.Protobuf.TestProtos.ForeignEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> repeatedForeignEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> RepeatedForeignEnum { get { return repeatedForeignEnum_; } } public const int RepeatedImportEnumFieldNumber = 53; - private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum> repeatedImportEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum>(); + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ImportEnum> _repeated_repeatedImportEnum_codec + = pb::FieldCodec.ForEnum(426, x => (int) x, x => (global::Google.Protobuf.TestProtos.ImportEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum> repeatedImportEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum> RepeatedImportEnum { get { return repeatedImportEnum_; } } public const int RepeatedPublicImportMessageFieldNumber = 54; + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.PublicImportMessage> _repeated_repeatedPublicImportMessage_codec + = pb::FieldCodec.ForMessage(434, global::Google.Protobuf.TestProtos.PublicImportMessage.Parser); private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.PublicImportMessage> repeatedPublicImportMessage_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.PublicImportMessage>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.PublicImportMessage> RepeatedPublicImportMessage { get { return repeatedPublicImportMessage_; } @@ -1136,88 +1177,28 @@ namespace Google.Protobuf.TestProtos { output.WriteRawTag(210, 1); output.WriteMessage(SinglePublicImportMessage); } - if (repeatedInt32_.Count > 0) { - output.WriteRawTag(250, 1); - output.WritePackedInt32Array(repeatedInt32_); - } - if (repeatedInt64_.Count > 0) { - output.WriteRawTag(130, 2); - output.WritePackedInt64Array(repeatedInt64_); - } - if (repeatedUint32_.Count > 0) { - output.WriteRawTag(138, 2); - output.WritePackedUInt32Array(repeatedUint32_); - } - if (repeatedUint64_.Count > 0) { - output.WriteRawTag(146, 2); - output.WritePackedUInt64Array(repeatedUint64_); - } - if (repeatedSint32_.Count > 0) { - output.WriteRawTag(154, 2); - output.WritePackedSInt32Array(repeatedSint32_); - } - if (repeatedSint64_.Count > 0) { - output.WriteRawTag(162, 2); - output.WritePackedSInt64Array(repeatedSint64_); - } - if (repeatedFixed32_.Count > 0) { - output.WriteRawTag(170, 2); - output.WritePackedFixed32Array(repeatedFixed32_); - } - if (repeatedFixed64_.Count > 0) { - output.WriteRawTag(178, 2); - output.WritePackedFixed64Array(repeatedFixed64_); - } - if (repeatedSfixed32_.Count > 0) { - output.WriteRawTag(186, 2); - output.WritePackedSFixed32Array(repeatedSfixed32_); - } - if (repeatedSfixed64_.Count > 0) { - output.WriteRawTag(194, 2); - output.WritePackedSFixed64Array(repeatedSfixed64_); - } - if (repeatedFloat_.Count > 0) { - output.WriteRawTag(202, 2); - output.WritePackedFloatArray(repeatedFloat_); - } - if (repeatedDouble_.Count > 0) { - output.WriteRawTag(210, 2); - output.WritePackedDoubleArray(repeatedDouble_); - } - if (repeatedBool_.Count > 0) { - output.WriteRawTag(218, 2); - output.WritePackedBoolArray(repeatedBool_); - } - if (repeatedString_.Count > 0) { - output.WriteStringArray(44, repeatedString_); - } - if (repeatedBytes_.Count > 0) { - output.WriteBytesArray(45, repeatedBytes_); - } - if (repeatedNestedMessage_.Count > 0) { - output.WriteMessageArray(48, repeatedNestedMessage_); - } - if (repeatedForeignMessage_.Count > 0) { - output.WriteMessageArray(49, repeatedForeignMessage_); - } - if (repeatedImportMessage_.Count > 0) { - output.WriteMessageArray(50, repeatedImportMessage_); - } - if (repeatedNestedEnum_.Count > 0) { - output.WriteRawTag(154, 3); - output.WritePackedEnumArray(repeatedNestedEnum_); - } - if (repeatedForeignEnum_.Count > 0) { - output.WriteRawTag(162, 3); - output.WritePackedEnumArray(repeatedForeignEnum_); - } - if (repeatedImportEnum_.Count > 0) { - output.WriteRawTag(170, 3); - output.WritePackedEnumArray(repeatedImportEnum_); - } - if (repeatedPublicImportMessage_.Count > 0) { - output.WriteMessageArray(54, repeatedPublicImportMessage_); - } + repeatedInt32_.WriteTo(output, _repeated_repeatedInt32_codec); + repeatedInt64_.WriteTo(output, _repeated_repeatedInt64_codec); + repeatedUint32_.WriteTo(output, _repeated_repeatedUint32_codec); + repeatedUint64_.WriteTo(output, _repeated_repeatedUint64_codec); + repeatedSint32_.WriteTo(output, _repeated_repeatedSint32_codec); + repeatedSint64_.WriteTo(output, _repeated_repeatedSint64_codec); + repeatedFixed32_.WriteTo(output, _repeated_repeatedFixed32_codec); + repeatedFixed64_.WriteTo(output, _repeated_repeatedFixed64_codec); + repeatedSfixed32_.WriteTo(output, _repeated_repeatedSfixed32_codec); + repeatedSfixed64_.WriteTo(output, _repeated_repeatedSfixed64_codec); + repeatedFloat_.WriteTo(output, _repeated_repeatedFloat_codec); + repeatedDouble_.WriteTo(output, _repeated_repeatedDouble_codec); + repeatedBool_.WriteTo(output, _repeated_repeatedBool_codec); + repeatedString_.WriteTo(output, _repeated_repeatedString_codec); + repeatedBytes_.WriteTo(output, _repeated_repeatedBytes_codec); + repeatedNestedMessage_.WriteTo(output, _repeated_repeatedNestedMessage_codec); + repeatedForeignMessage_.WriteTo(output, _repeated_repeatedForeignMessage_codec); + repeatedImportMessage_.WriteTo(output, _repeated_repeatedImportMessage_codec); + repeatedNestedEnum_.WriteTo(output, _repeated_repeatedNestedEnum_codec); + repeatedForeignEnum_.WriteTo(output, _repeated_repeatedForeignEnum_codec); + repeatedImportEnum_.WriteTo(output, _repeated_repeatedImportEnum_codec); + repeatedPublicImportMessage_.WriteTo(output, _repeated_repeatedPublicImportMessage_codec); if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) { output.WriteRawTag(248, 6); output.WriteUInt32(OneofUint32); @@ -1304,160 +1285,28 @@ namespace Google.Protobuf.TestProtos { if (singlePublicImportMessage_ != null) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(SinglePublicImportMessage); } - if (repeatedInt32_.Count > 0) { - int dataSize = 0; - foreach (int element in repeatedInt32_) { - dataSize += pb::CodedOutputStream.ComputeInt32Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedInt64_.Count > 0) { - int dataSize = 0; - foreach (long element in repeatedInt64_) { - dataSize += pb::CodedOutputStream.ComputeInt64Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedUint32_.Count > 0) { - int dataSize = 0; - foreach (uint element in repeatedUint32_) { - dataSize += pb::CodedOutputStream.ComputeUInt32Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedUint64_.Count > 0) { - int dataSize = 0; - foreach (ulong element in repeatedUint64_) { - dataSize += pb::CodedOutputStream.ComputeUInt64Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedSint32_.Count > 0) { - int dataSize = 0; - foreach (int element in repeatedSint32_) { - dataSize += pb::CodedOutputStream.ComputeSInt32Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedSint64_.Count > 0) { - int dataSize = 0; - foreach (long element in repeatedSint64_) { - dataSize += pb::CodedOutputStream.ComputeSInt64Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedFixed32_.Count > 0) { - int dataSize = 0; - dataSize = 4 * repeatedFixed32_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedFixed64_.Count > 0) { - int dataSize = 0; - dataSize = 8 * repeatedFixed64_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedSfixed32_.Count > 0) { - int dataSize = 0; - dataSize = 4 * repeatedSfixed32_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedSfixed64_.Count > 0) { - int dataSize = 0; - dataSize = 8 * repeatedSfixed64_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedFloat_.Count > 0) { - int dataSize = 0; - dataSize = 4 * repeatedFloat_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedDouble_.Count > 0) { - int dataSize = 0; - dataSize = 8 * repeatedDouble_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedBool_.Count > 0) { - int dataSize = 0; - dataSize = 1 * repeatedBool_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedString_.Count > 0) { - int dataSize = 0; - foreach (string element in repeatedString_) { - dataSize += pb::CodedOutputStream.ComputeStringSize(element); - } - size += dataSize; - size += 2 * repeatedString_.Count; - } - if (repeatedBytes_.Count > 0) { - int dataSize = 0; - foreach (pb::ByteString element in repeatedBytes_) { - dataSize += pb::CodedOutputStream.ComputeBytesSize(element); - } - size += dataSize; - size += 2 * repeatedBytes_.Count; - } - if (repeatedNestedMessage_.Count > 0) { - foreach (global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage element in repeatedNestedMessage_) { - size += pb::CodedOutputStream.ComputeMessageSize(element); - } - size += 2 * repeatedNestedMessage_.Count; - } - if (repeatedForeignMessage_.Count > 0) { - foreach (global::Google.Protobuf.TestProtos.ForeignMessage element in repeatedForeignMessage_) { - size += pb::CodedOutputStream.ComputeMessageSize(element); - } - size += 2 * repeatedForeignMessage_.Count; - } - if (repeatedImportMessage_.Count > 0) { - foreach (global::Google.Protobuf.TestProtos.ImportMessage element in repeatedImportMessage_) { - size += pb::CodedOutputStream.ComputeMessageSize(element); - } - size += 2 * repeatedImportMessage_.Count; - } - if (repeatedNestedEnum_.Count > 0) { - int dataSize = 0; - foreach (global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum element in repeatedNestedEnum_) { - dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); - } - if (repeatedForeignEnum_.Count > 0) { - int dataSize = 0; - foreach (global::Google.Protobuf.TestProtos.ForeignEnum element in repeatedForeignEnum_) { - dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); - } - if (repeatedImportEnum_.Count > 0) { - int dataSize = 0; - foreach (global::Google.Protobuf.TestProtos.ImportEnum element in repeatedImportEnum_) { - dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); - } - if (repeatedPublicImportMessage_.Count > 0) { - foreach (global::Google.Protobuf.TestProtos.PublicImportMessage element in repeatedPublicImportMessage_) { - size += pb::CodedOutputStream.ComputeMessageSize(element); - } - size += 2 * repeatedPublicImportMessage_.Count; - } + size += repeatedInt32_.CalculateSize(_repeated_repeatedInt32_codec); + size += repeatedInt64_.CalculateSize(_repeated_repeatedInt64_codec); + size += repeatedUint32_.CalculateSize(_repeated_repeatedUint32_codec); + size += repeatedUint64_.CalculateSize(_repeated_repeatedUint64_codec); + size += repeatedSint32_.CalculateSize(_repeated_repeatedSint32_codec); + size += repeatedSint64_.CalculateSize(_repeated_repeatedSint64_codec); + size += repeatedFixed32_.CalculateSize(_repeated_repeatedFixed32_codec); + size += repeatedFixed64_.CalculateSize(_repeated_repeatedFixed64_codec); + size += repeatedSfixed32_.CalculateSize(_repeated_repeatedSfixed32_codec); + size += repeatedSfixed64_.CalculateSize(_repeated_repeatedSfixed64_codec); + size += repeatedFloat_.CalculateSize(_repeated_repeatedFloat_codec); + size += repeatedDouble_.CalculateSize(_repeated_repeatedDouble_codec); + size += repeatedBool_.CalculateSize(_repeated_repeatedBool_codec); + size += repeatedString_.CalculateSize(_repeated_repeatedString_codec); + size += repeatedBytes_.CalculateSize(_repeated_repeatedBytes_codec); + size += repeatedNestedMessage_.CalculateSize(_repeated_repeatedNestedMessage_codec); + size += repeatedForeignMessage_.CalculateSize(_repeated_repeatedForeignMessage_codec); + size += repeatedImportMessage_.CalculateSize(_repeated_repeatedImportMessage_codec); + size += repeatedNestedEnum_.CalculateSize(_repeated_repeatedNestedEnum_codec); + size += repeatedForeignEnum_.CalculateSize(_repeated_repeatedForeignEnum_codec); + size += repeatedImportEnum_.CalculateSize(_repeated_repeatedImportEnum_codec); + size += repeatedPublicImportMessage_.CalculateSize(_repeated_repeatedPublicImportMessage_codec); if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) { size += 2 + pb::CodedOutputStream.ComputeUInt32Size(OneofUint32); } @@ -1707,106 +1556,106 @@ namespace Google.Protobuf.TestProtos { } case 250: case 248: { - input.ReadInt32Array(repeatedInt32_); + repeatedInt32_.AddEntriesFrom(input, _repeated_repeatedInt32_codec); break; } case 258: case 256: { - input.ReadInt64Array(repeatedInt64_); + repeatedInt64_.AddEntriesFrom(input, _repeated_repeatedInt64_codec); break; } case 266: case 264: { - input.ReadUInt32Array(repeatedUint32_); + repeatedUint32_.AddEntriesFrom(input, _repeated_repeatedUint32_codec); break; } case 274: case 272: { - input.ReadUInt64Array(repeatedUint64_); + repeatedUint64_.AddEntriesFrom(input, _repeated_repeatedUint64_codec); break; } case 282: case 280: { - input.ReadSInt32Array(repeatedSint32_); + repeatedSint32_.AddEntriesFrom(input, _repeated_repeatedSint32_codec); break; } case 290: case 288: { - input.ReadSInt64Array(repeatedSint64_); + repeatedSint64_.AddEntriesFrom(input, _repeated_repeatedSint64_codec); break; } case 298: case 301: { - input.ReadFixed32Array(repeatedFixed32_); + repeatedFixed32_.AddEntriesFrom(input, _repeated_repeatedFixed32_codec); break; } case 306: case 305: { - input.ReadFixed64Array(repeatedFixed64_); + repeatedFixed64_.AddEntriesFrom(input, _repeated_repeatedFixed64_codec); break; } case 314: case 317: { - input.ReadSFixed32Array(repeatedSfixed32_); + repeatedSfixed32_.AddEntriesFrom(input, _repeated_repeatedSfixed32_codec); break; } case 322: case 321: { - input.ReadSFixed64Array(repeatedSfixed64_); + repeatedSfixed64_.AddEntriesFrom(input, _repeated_repeatedSfixed64_codec); break; } case 330: case 333: { - input.ReadFloatArray(repeatedFloat_); + repeatedFloat_.AddEntriesFrom(input, _repeated_repeatedFloat_codec); break; } case 338: case 337: { - input.ReadDoubleArray(repeatedDouble_); + repeatedDouble_.AddEntriesFrom(input, _repeated_repeatedDouble_codec); break; } case 346: case 344: { - input.ReadBoolArray(repeatedBool_); + repeatedBool_.AddEntriesFrom(input, _repeated_repeatedBool_codec); break; } case 354: { - input.ReadStringArray(repeatedString_); + repeatedString_.AddEntriesFrom(input, _repeated_repeatedString_codec); break; } case 362: { - input.ReadBytesArray(repeatedBytes_); + repeatedBytes_.AddEntriesFrom(input, _repeated_repeatedBytes_codec); break; } case 386: { - input.ReadMessageArray(repeatedNestedMessage_, global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage.Parser); + repeatedNestedMessage_.AddEntriesFrom(input, _repeated_repeatedNestedMessage_codec); break; } case 394: { - input.ReadMessageArray(repeatedForeignMessage_, global::Google.Protobuf.TestProtos.ForeignMessage.Parser); + repeatedForeignMessage_.AddEntriesFrom(input, _repeated_repeatedForeignMessage_codec); break; } case 402: { - input.ReadMessageArray(repeatedImportMessage_, global::Google.Protobuf.TestProtos.ImportMessage.Parser); + repeatedImportMessage_.AddEntriesFrom(input, _repeated_repeatedImportMessage_codec); break; } case 410: case 408: { - input.ReadEnumArray<global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum>(repeatedNestedEnum_); + repeatedNestedEnum_.AddEntriesFrom(input, _repeated_repeatedNestedEnum_codec); break; } case 418: case 416: { - input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(repeatedForeignEnum_); + repeatedForeignEnum_.AddEntriesFrom(input, _repeated_repeatedForeignEnum_codec); break; } case 426: case 424: { - input.ReadEnumArray<global::Google.Protobuf.TestProtos.ImportEnum>(repeatedImportEnum_); + repeatedImportEnum_.AddEntriesFrom(input, _repeated_repeatedImportEnum_codec); break; } case 434: { - input.ReadMessageArray(repeatedPublicImportMessage_, global::Google.Protobuf.TestProtos.PublicImportMessage.Parser); + repeatedPublicImportMessage_.AddEntriesFrom(input, _repeated_repeatedPublicImportMessage_codec); break; } case 888: { @@ -2022,6 +1871,8 @@ namespace Google.Protobuf.TestProtos { } public const int RepeatedChildFieldNumber = 3; + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.NestedTestAllTypes> _repeated_repeatedChild_codec + = pb::FieldCodec.ForMessage(26, global::Google.Protobuf.TestProtos.NestedTestAllTypes.Parser); private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.NestedTestAllTypes> repeatedChild_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.NestedTestAllTypes>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.NestedTestAllTypes> RepeatedChild { get { return repeatedChild_; } @@ -2061,9 +1912,7 @@ namespace Google.Protobuf.TestProtos { output.WriteRawTag(18); output.WriteMessage(Payload); } - if (repeatedChild_.Count > 0) { - output.WriteMessageArray(3, repeatedChild_); - } + repeatedChild_.WriteTo(output, _repeated_repeatedChild_codec); } public int CalculateSize() { @@ -2074,12 +1923,7 @@ namespace Google.Protobuf.TestProtos { if (payload_ != null) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(Payload); } - if (repeatedChild_.Count > 0) { - foreach (global::Google.Protobuf.TestProtos.NestedTestAllTypes element in repeatedChild_) { - size += pb::CodedOutputStream.ComputeMessageSize(element); - } - size += 1 * repeatedChild_.Count; - } + size += repeatedChild_.CalculateSize(_repeated_repeatedChild_codec); return size; } @@ -2128,7 +1972,7 @@ namespace Google.Protobuf.TestProtos { break; } case 26: { - input.ReadMessageArray(repeatedChild_, global::Google.Protobuf.TestProtos.NestedTestAllTypes.Parser); + repeatedChild_.AddEntriesFrom(input, _repeated_repeatedChild_codec); break; } } @@ -3196,24 +3040,31 @@ namespace Google.Protobuf.TestProtos { } public const int RepeatedPrimitiveFieldFieldNumber = 7; + private static readonly pb::FieldCodec<int> _repeated_repeatedPrimitiveField_codec + = pb::FieldCodec.ForInt32(58); private readonly pbc::RepeatedField<int> repeatedPrimitiveField_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> RepeatedPrimitiveField { get { return repeatedPrimitiveField_; } } public const int RepeatedStringFieldFieldNumber = 8; + private static readonly pb::FieldCodec<string> _repeated_repeatedStringField_codec + = pb::FieldCodec.ForString(66); private readonly pbc::RepeatedField<string> repeatedStringField_ = new pbc::RepeatedField<string>(); public pbc::RepeatedField<string> RepeatedStringField { get { return repeatedStringField_; } } public const int RepeatedEnumFieldFieldNumber = 9; - private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> repeatedEnumField_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>(); + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignEnum> _repeated_repeatedEnumField_codec + = pb::FieldCodec.ForEnum(74, x => (int) x, x => (global::Google.Protobuf.TestProtos.ForeignEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> repeatedEnumField_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> RepeatedEnumField { get { return repeatedEnumField_; } } public const int RepeatedMessageFieldFieldNumber = 10; + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignMessage> _repeated_repeatedMessageField_codec + = pb::FieldCodec.ForMessage(82, global::Google.Protobuf.TestProtos.ForeignMessage.Parser); private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> repeatedMessageField_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> RepeatedMessageField { get { return repeatedMessageField_; } @@ -3271,20 +3122,10 @@ namespace Google.Protobuf.TestProtos { output.WriteRawTag(34); output.WriteMessage(MessageField); } - if (repeatedPrimitiveField_.Count > 0) { - output.WriteRawTag(58); - output.WritePackedInt32Array(repeatedPrimitiveField_); - } - if (repeatedStringField_.Count > 0) { - output.WriteStringArray(8, repeatedStringField_); - } - if (repeatedEnumField_.Count > 0) { - output.WriteRawTag(74); - output.WritePackedEnumArray(repeatedEnumField_); - } - if (repeatedMessageField_.Count > 0) { - output.WriteMessageArray(10, repeatedMessageField_); - } + repeatedPrimitiveField_.WriteTo(output, _repeated_repeatedPrimitiveField_codec); + repeatedStringField_.WriteTo(output, _repeated_repeatedStringField_codec); + repeatedEnumField_.WriteTo(output, _repeated_repeatedEnumField_codec); + repeatedMessageField_.WriteTo(output, _repeated_repeatedMessageField_codec); } public int CalculateSize() { @@ -3301,36 +3142,10 @@ namespace Google.Protobuf.TestProtos { if (messageField_ != null) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(MessageField); } - if (repeatedPrimitiveField_.Count > 0) { - int dataSize = 0; - foreach (int element in repeatedPrimitiveField_) { - dataSize += pb::CodedOutputStream.ComputeInt32Size(element); - } - size += dataSize; - size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedStringField_.Count > 0) { - int dataSize = 0; - foreach (string element in repeatedStringField_) { - dataSize += pb::CodedOutputStream.ComputeStringSize(element); - } - size += dataSize; - size += 1 * repeatedStringField_.Count; - } - if (repeatedEnumField_.Count > 0) { - int dataSize = 0; - foreach (global::Google.Protobuf.TestProtos.ForeignEnum element in repeatedEnumField_) { - dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); - } - size += dataSize; - size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); - } - if (repeatedMessageField_.Count > 0) { - foreach (global::Google.Protobuf.TestProtos.ForeignMessage element in repeatedMessageField_) { - size += pb::CodedOutputStream.ComputeMessageSize(element); - } - size += 1 * repeatedMessageField_.Count; - } + size += repeatedPrimitiveField_.CalculateSize(_repeated_repeatedPrimitiveField_codec); + size += repeatedStringField_.CalculateSize(_repeated_repeatedStringField_codec); + size += repeatedEnumField_.CalculateSize(_repeated_repeatedEnumField_codec); + size += repeatedMessageField_.CalculateSize(_repeated_repeatedMessageField_codec); return size; } @@ -3391,20 +3206,20 @@ namespace Google.Protobuf.TestProtos { } case 58: case 56: { - input.ReadInt32Array(repeatedPrimitiveField_); + repeatedPrimitiveField_.AddEntriesFrom(input, _repeated_repeatedPrimitiveField_codec); break; } case 66: { - input.ReadStringArray(repeatedStringField_); + repeatedStringField_.AddEntriesFrom(input, _repeated_repeatedStringField_codec); break; } case 74: case 72: { - input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(repeatedEnumField_); + repeatedEnumField_.AddEntriesFrom(input, _repeated_repeatedEnumField_codec); break; } case 82: { - input.ReadMessageArray(repeatedMessageField_, global::Google.Protobuf.TestProtos.ForeignMessage.Parser); + repeatedMessageField_.AddEntriesFrom(input, _repeated_repeatedMessageField_codec); break; } } @@ -4015,6 +3830,8 @@ namespace Google.Protobuf.TestProtos { } public const int DataFieldNumber = 1; + private static readonly pb::FieldCodec<string> _repeated_data_codec + = pb::FieldCodec.ForString(10); private readonly pbc::RepeatedField<string> data_ = new pbc::RepeatedField<string>(); public pbc::RepeatedField<string> Data { get { return data_; } @@ -4042,21 +3859,12 @@ namespace Google.Protobuf.TestProtos { } public void WriteTo(pb::CodedOutputStream output) { - if (data_.Count > 0) { - output.WriteStringArray(1, data_); - } + data_.WriteTo(output, _repeated_data_codec); } public int CalculateSize() { int size = 0; - if (data_.Count > 0) { - int dataSize = 0; - foreach (string element in data_) { - dataSize += pb::CodedOutputStream.ComputeStringSize(element); - } - size += dataSize; - size += 1 * data_.Count; - } + size += data_.CalculateSize(_repeated_data_codec); return size; } @@ -4079,7 +3887,7 @@ namespace Google.Protobuf.TestProtos { } break; case 10: { - input.ReadStringArray(data_); + data_.AddEntriesFrom(input, _repeated_data_codec); break; } } @@ -5129,85 +4937,112 @@ namespace Google.Protobuf.TestProtos { } public const int PackedInt32FieldNumber = 90; + private static readonly pb::FieldCodec<int> _repeated_packedInt32_codec + = pb::FieldCodec.ForInt32(722); private readonly pbc::RepeatedField<int> packedInt32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> PackedInt32 { get { return packedInt32_; } } public const int PackedInt64FieldNumber = 91; + private static readonly pb::FieldCodec<long> _repeated_packedInt64_codec + = pb::FieldCodec.ForInt64(730); private readonly pbc::RepeatedField<long> packedInt64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> PackedInt64 { get { return packedInt64_; } } public const int PackedUint32FieldNumber = 92; + private static readonly pb::FieldCodec<uint> _repeated_packedUint32_codec + = pb::FieldCodec.ForUInt32(738); private readonly pbc::RepeatedField<uint> packedUint32_ = new pbc::RepeatedField<uint>(); public pbc::RepeatedField<uint> PackedUint32 { get { return packedUint32_; } } public const int PackedUint64FieldNumber = 93; + private static readonly pb::FieldCodec<ulong> _repeated_packedUint64_codec + = pb::FieldCodec.ForUInt64(746); private readonly pbc::RepeatedField<ulong> packedUint64_ = new pbc::RepeatedField<ulong>(); public pbc::RepeatedField<ulong> PackedUint64 { get { return packedUint64_; } } public const int PackedSint32FieldNumber = 94; + private static readonly pb::FieldCodec<int> _repeated_packedSint32_codec + = pb::FieldCodec.ForSInt32(754); private readonly pbc::RepeatedField<int> packedSint32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> PackedSint32 { get { return packedSint32_; } } public const int PackedSint64FieldNumber = 95; + private static readonly pb::FieldCodec<long> _repeated_packedSint64_codec + = pb::FieldCodec.ForSInt64(762); private readonly pbc::RepeatedField<long> packedSint64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> PackedSint64 { get { return packedSint64_; } } public const int PackedFixed32FieldNumber = 96; + private static readonly pb::FieldCodec<uint> _repeated_packedFixed32_codec + = pb::FieldCodec.ForFixed32(770); private readonly pbc::RepeatedField<uint> packedFixed32_ = new pbc::RepeatedField<uint>(); public pbc::RepeatedField<uint> PackedFixed32 { get { return packedFixed32_; } } public const int PackedFixed64FieldNumber = 97; + private static readonly pb::FieldCodec<ulong> _repeated_packedFixed64_codec + = pb::FieldCodec.ForFixed64(778); private readonly pbc::RepeatedField<ulong> packedFixed64_ = new pbc::RepeatedField<ulong>(); public pbc::RepeatedField<ulong> PackedFixed64 { get { return packedFixed64_; } } public const int PackedSfixed32FieldNumber = 98; + private static readonly pb::FieldCodec<int> _repeated_packedSfixed32_codec + = pb::FieldCodec.ForSFixed32(786); private readonly pbc::RepeatedField<int> packedSfixed32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> PackedSfixed32 { get { return packedSfixed32_; } } public const int PackedSfixed64FieldNumber = 99; + private static readonly pb::FieldCodec<long> _repeated_packedSfixed64_codec + = pb::FieldCodec.ForSFixed64(794); private readonly pbc::RepeatedField<long> packedSfixed64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> PackedSfixed64 { get { return packedSfixed64_; } } public const int PackedFloatFieldNumber = 100; + private static readonly pb::FieldCodec<float> _repeated_packedFloat_codec + = pb::FieldCodec.ForFloat(802); private readonly pbc::RepeatedField<float> packedFloat_ = new pbc::RepeatedField<float>(); public pbc::RepeatedField<float> PackedFloat { get { return packedFloat_; } } public const int PackedDoubleFieldNumber = 101; + private static readonly pb::FieldCodec<double> _repeated_packedDouble_codec + = pb::FieldCodec.ForDouble(810); private readonly pbc::RepeatedField<double> packedDouble_ = new pbc::RepeatedField<double>(); public pbc::RepeatedField<double> PackedDouble { get { return packedDouble_; } } public const int PackedBoolFieldNumber = 102; + private static readonly pb::FieldCodec<bool> _repeated_packedBool_codec + = pb::FieldCodec.ForBool(818); private readonly pbc::RepeatedField<bool> packedBool_ = new pbc::RepeatedField<bool>(); public pbc::RepeatedField<bool> PackedBool { get { return packedBool_; } } public const int PackedEnumFieldNumber = 103; - private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> packedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>(); + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignEnum> _repeated_packedEnum_codec + = pb::FieldCodec.ForEnum(826, x => (int) x, x => (global::Google.Protobuf.TestProtos.ForeignEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> packedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> PackedEnum { get { return packedEnum_; } } @@ -5260,164 +5095,38 @@ namespace Google.Protobuf.TestProtos { } public void WriteTo(pb::CodedOutputStream output) { - if (packedInt32_.Count > 0) { - output.WriteRawTag(210, 5); - output.WritePackedInt32Array(packedInt32_); - } - if (packedInt64_.Count > 0) { - output.WriteRawTag(218, 5); - output.WritePackedInt64Array(packedInt64_); - } - if (packedUint32_.Count > 0) { - output.WriteRawTag(226, 5); - output.WritePackedUInt32Array(packedUint32_); - } - if (packedUint64_.Count > 0) { - output.WriteRawTag(234, 5); - output.WritePackedUInt64Array(packedUint64_); - } - if (packedSint32_.Count > 0) { - output.WriteRawTag(242, 5); - output.WritePackedSInt32Array(packedSint32_); - } - if (packedSint64_.Count > 0) { - output.WriteRawTag(250, 5); - output.WritePackedSInt64Array(packedSint64_); - } - if (packedFixed32_.Count > 0) { - output.WriteRawTag(130, 6); - output.WritePackedFixed32Array(packedFixed32_); - } - if (packedFixed64_.Count > 0) { - output.WriteRawTag(138, 6); - output.WritePackedFixed64Array(packedFixed64_); - } - if (packedSfixed32_.Count > 0) { - output.WriteRawTag(146, 6); - output.WritePackedSFixed32Array(packedSfixed32_); - } - if (packedSfixed64_.Count > 0) { - output.WriteRawTag(154, 6); - output.WritePackedSFixed64Array(packedSfixed64_); - } - if (packedFloat_.Count > 0) { - output.WriteRawTag(162, 6); - output.WritePackedFloatArray(packedFloat_); - } - if (packedDouble_.Count > 0) { - output.WriteRawTag(170, 6); - output.WritePackedDoubleArray(packedDouble_); - } - if (packedBool_.Count > 0) { - output.WriteRawTag(178, 6); - output.WritePackedBoolArray(packedBool_); - } - if (packedEnum_.Count > 0) { - output.WriteRawTag(186, 6); - output.WritePackedEnumArray(packedEnum_); - } + packedInt32_.WriteTo(output, _repeated_packedInt32_codec); + packedInt64_.WriteTo(output, _repeated_packedInt64_codec); + packedUint32_.WriteTo(output, _repeated_packedUint32_codec); + packedUint64_.WriteTo(output, _repeated_packedUint64_codec); + packedSint32_.WriteTo(output, _repeated_packedSint32_codec); + packedSint64_.WriteTo(output, _repeated_packedSint64_codec); + packedFixed32_.WriteTo(output, _repeated_packedFixed32_codec); + packedFixed64_.WriteTo(output, _repeated_packedFixed64_codec); + packedSfixed32_.WriteTo(output, _repeated_packedSfixed32_codec); + packedSfixed64_.WriteTo(output, _repeated_packedSfixed64_codec); + packedFloat_.WriteTo(output, _repeated_packedFloat_codec); + packedDouble_.WriteTo(output, _repeated_packedDouble_codec); + packedBool_.WriteTo(output, _repeated_packedBool_codec); + packedEnum_.WriteTo(output, _repeated_packedEnum_codec); } public int CalculateSize() { int size = 0; - if (packedInt32_.Count > 0) { - int dataSize = 0; - foreach (int element in packedInt32_) { - dataSize += pb::CodedOutputStream.ComputeInt32Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedInt64_.Count > 0) { - int dataSize = 0; - foreach (long element in packedInt64_) { - dataSize += pb::CodedOutputStream.ComputeInt64Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedUint32_.Count > 0) { - int dataSize = 0; - foreach (uint element in packedUint32_) { - dataSize += pb::CodedOutputStream.ComputeUInt32Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedUint64_.Count > 0) { - int dataSize = 0; - foreach (ulong element in packedUint64_) { - dataSize += pb::CodedOutputStream.ComputeUInt64Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedSint32_.Count > 0) { - int dataSize = 0; - foreach (int element in packedSint32_) { - dataSize += pb::CodedOutputStream.ComputeSInt32Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedSint64_.Count > 0) { - int dataSize = 0; - foreach (long element in packedSint64_) { - dataSize += pb::CodedOutputStream.ComputeSInt64Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedFixed32_.Count > 0) { - int dataSize = 0; - dataSize = 4 * packedFixed32_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedFixed64_.Count > 0) { - int dataSize = 0; - dataSize = 8 * packedFixed64_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedSfixed32_.Count > 0) { - int dataSize = 0; - dataSize = 4 * packedSfixed32_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedSfixed64_.Count > 0) { - int dataSize = 0; - dataSize = 8 * packedSfixed64_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedFloat_.Count > 0) { - int dataSize = 0; - dataSize = 4 * packedFloat_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedDouble_.Count > 0) { - int dataSize = 0; - dataSize = 8 * packedDouble_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedBool_.Count > 0) { - int dataSize = 0; - dataSize = 1 * packedBool_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (packedEnum_.Count > 0) { - int dataSize = 0; - foreach (global::Google.Protobuf.TestProtos.ForeignEnum element in packedEnum_) { - dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); - } + size += packedInt32_.CalculateSize(_repeated_packedInt32_codec); + size += packedInt64_.CalculateSize(_repeated_packedInt64_codec); + size += packedUint32_.CalculateSize(_repeated_packedUint32_codec); + size += packedUint64_.CalculateSize(_repeated_packedUint64_codec); + size += packedSint32_.CalculateSize(_repeated_packedSint32_codec); + size += packedSint64_.CalculateSize(_repeated_packedSint64_codec); + size += packedFixed32_.CalculateSize(_repeated_packedFixed32_codec); + size += packedFixed64_.CalculateSize(_repeated_packedFixed64_codec); + size += packedSfixed32_.CalculateSize(_repeated_packedSfixed32_codec); + size += packedSfixed64_.CalculateSize(_repeated_packedSfixed64_codec); + size += packedFloat_.CalculateSize(_repeated_packedFloat_codec); + size += packedDouble_.CalculateSize(_repeated_packedDouble_codec); + size += packedBool_.CalculateSize(_repeated_packedBool_codec); + size += packedEnum_.CalculateSize(_repeated_packedEnum_codec); return size; } @@ -5454,72 +5163,72 @@ namespace Google.Protobuf.TestProtos { break; case 722: case 720: { - input.ReadInt32Array(packedInt32_); + packedInt32_.AddEntriesFrom(input, _repeated_packedInt32_codec); break; } case 730: case 728: { - input.ReadInt64Array(packedInt64_); + packedInt64_.AddEntriesFrom(input, _repeated_packedInt64_codec); break; } case 738: case 736: { - input.ReadUInt32Array(packedUint32_); + packedUint32_.AddEntriesFrom(input, _repeated_packedUint32_codec); break; } case 746: case 744: { - input.ReadUInt64Array(packedUint64_); + packedUint64_.AddEntriesFrom(input, _repeated_packedUint64_codec); break; } case 754: case 752: { - input.ReadSInt32Array(packedSint32_); + packedSint32_.AddEntriesFrom(input, _repeated_packedSint32_codec); break; } case 762: case 760: { - input.ReadSInt64Array(packedSint64_); + packedSint64_.AddEntriesFrom(input, _repeated_packedSint64_codec); break; } case 770: case 773: { - input.ReadFixed32Array(packedFixed32_); + packedFixed32_.AddEntriesFrom(input, _repeated_packedFixed32_codec); break; } case 778: case 777: { - input.ReadFixed64Array(packedFixed64_); + packedFixed64_.AddEntriesFrom(input, _repeated_packedFixed64_codec); break; } case 786: case 789: { - input.ReadSFixed32Array(packedSfixed32_); + packedSfixed32_.AddEntriesFrom(input, _repeated_packedSfixed32_codec); break; } case 794: case 793: { - input.ReadSFixed64Array(packedSfixed64_); + packedSfixed64_.AddEntriesFrom(input, _repeated_packedSfixed64_codec); break; } case 802: case 805: { - input.ReadFloatArray(packedFloat_); + packedFloat_.AddEntriesFrom(input, _repeated_packedFloat_codec); break; } case 810: case 809: { - input.ReadDoubleArray(packedDouble_); + packedDouble_.AddEntriesFrom(input, _repeated_packedDouble_codec); break; } case 818: case 816: { - input.ReadBoolArray(packedBool_); + packedBool_.AddEntriesFrom(input, _repeated_packedBool_codec); break; } case 826: case 824: { - input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(packedEnum_); + packedEnum_.AddEntriesFrom(input, _repeated_packedEnum_codec); break; } } @@ -5591,85 +5300,112 @@ namespace Google.Protobuf.TestProtos { } public const int UnpackedInt32FieldNumber = 90; + private static readonly pb::FieldCodec<int> _repeated_unpackedInt32_codec + = pb::FieldCodec.ForInt32(720); private readonly pbc::RepeatedField<int> unpackedInt32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> UnpackedInt32 { get { return unpackedInt32_; } } public const int UnpackedInt64FieldNumber = 91; + private static readonly pb::FieldCodec<long> _repeated_unpackedInt64_codec + = pb::FieldCodec.ForInt64(728); private readonly pbc::RepeatedField<long> unpackedInt64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> UnpackedInt64 { get { return unpackedInt64_; } } public const int UnpackedUint32FieldNumber = 92; + private static readonly pb::FieldCodec<uint> _repeated_unpackedUint32_codec + = pb::FieldCodec.ForUInt32(736); private readonly pbc::RepeatedField<uint> unpackedUint32_ = new pbc::RepeatedField<uint>(); public pbc::RepeatedField<uint> UnpackedUint32 { get { return unpackedUint32_; } } public const int UnpackedUint64FieldNumber = 93; + private static readonly pb::FieldCodec<ulong> _repeated_unpackedUint64_codec + = pb::FieldCodec.ForUInt64(744); private readonly pbc::RepeatedField<ulong> unpackedUint64_ = new pbc::RepeatedField<ulong>(); public pbc::RepeatedField<ulong> UnpackedUint64 { get { return unpackedUint64_; } } public const int UnpackedSint32FieldNumber = 94; + private static readonly pb::FieldCodec<int> _repeated_unpackedSint32_codec + = pb::FieldCodec.ForSInt32(752); private readonly pbc::RepeatedField<int> unpackedSint32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> UnpackedSint32 { get { return unpackedSint32_; } } public const int UnpackedSint64FieldNumber = 95; + private static readonly pb::FieldCodec<long> _repeated_unpackedSint64_codec + = pb::FieldCodec.ForSInt64(760); private readonly pbc::RepeatedField<long> unpackedSint64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> UnpackedSint64 { get { return unpackedSint64_; } } public const int UnpackedFixed32FieldNumber = 96; + private static readonly pb::FieldCodec<uint> _repeated_unpackedFixed32_codec + = pb::FieldCodec.ForFixed32(773); private readonly pbc::RepeatedField<uint> unpackedFixed32_ = new pbc::RepeatedField<uint>(); public pbc::RepeatedField<uint> UnpackedFixed32 { get { return unpackedFixed32_; } } public const int UnpackedFixed64FieldNumber = 97; + private static readonly pb::FieldCodec<ulong> _repeated_unpackedFixed64_codec + = pb::FieldCodec.ForFixed64(777); private readonly pbc::RepeatedField<ulong> unpackedFixed64_ = new pbc::RepeatedField<ulong>(); public pbc::RepeatedField<ulong> UnpackedFixed64 { get { return unpackedFixed64_; } } public const int UnpackedSfixed32FieldNumber = 98; + private static readonly pb::FieldCodec<int> _repeated_unpackedSfixed32_codec + = pb::FieldCodec.ForSFixed32(789); private readonly pbc::RepeatedField<int> unpackedSfixed32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> UnpackedSfixed32 { get { return unpackedSfixed32_; } } public const int UnpackedSfixed64FieldNumber = 99; + private static readonly pb::FieldCodec<long> _repeated_unpackedSfixed64_codec + = pb::FieldCodec.ForSFixed64(793); private readonly pbc::RepeatedField<long> unpackedSfixed64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> UnpackedSfixed64 { get { return unpackedSfixed64_; } } public const int UnpackedFloatFieldNumber = 100; + private static readonly pb::FieldCodec<float> _repeated_unpackedFloat_codec + = pb::FieldCodec.ForFloat(805); private readonly pbc::RepeatedField<float> unpackedFloat_ = new pbc::RepeatedField<float>(); public pbc::RepeatedField<float> UnpackedFloat { get { return unpackedFloat_; } } public const int UnpackedDoubleFieldNumber = 101; + private static readonly pb::FieldCodec<double> _repeated_unpackedDouble_codec + = pb::FieldCodec.ForDouble(809); private readonly pbc::RepeatedField<double> unpackedDouble_ = new pbc::RepeatedField<double>(); public pbc::RepeatedField<double> UnpackedDouble { get { return unpackedDouble_; } } public const int UnpackedBoolFieldNumber = 102; + private static readonly pb::FieldCodec<bool> _repeated_unpackedBool_codec + = pb::FieldCodec.ForBool(816); private readonly pbc::RepeatedField<bool> unpackedBool_ = new pbc::RepeatedField<bool>(); public pbc::RepeatedField<bool> UnpackedBool { get { return unpackedBool_; } } public const int UnpackedEnumFieldNumber = 103; - private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> unpackedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>(); + private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.ForeignEnum> _repeated_unpackedEnum_codec + = pb::FieldCodec.ForEnum(824, x => (int) x, x => (global::Google.Protobuf.TestProtos.ForeignEnum) x);private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> unpackedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum>(); public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> UnpackedEnum { get { return unpackedEnum_; } } @@ -5722,150 +5458,38 @@ namespace Google.Protobuf.TestProtos { } public void WriteTo(pb::CodedOutputStream output) { - if (unpackedInt32_.Count > 0) { - output.WriteInt32Array(90, unpackedInt32_); - } - if (unpackedInt64_.Count > 0) { - output.WriteInt64Array(91, unpackedInt64_); - } - if (unpackedUint32_.Count > 0) { - output.WriteUInt32Array(92, unpackedUint32_); - } - if (unpackedUint64_.Count > 0) { - output.WriteUInt64Array(93, unpackedUint64_); - } - if (unpackedSint32_.Count > 0) { - output.WriteSInt32Array(94, unpackedSint32_); - } - if (unpackedSint64_.Count > 0) { - output.WriteSInt64Array(95, unpackedSint64_); - } - if (unpackedFixed32_.Count > 0) { - output.WriteFixed32Array(96, unpackedFixed32_); - } - if (unpackedFixed64_.Count > 0) { - output.WriteFixed64Array(97, unpackedFixed64_); - } - if (unpackedSfixed32_.Count > 0) { - output.WriteSFixed32Array(98, unpackedSfixed32_); - } - if (unpackedSfixed64_.Count > 0) { - output.WriteSFixed64Array(99, unpackedSfixed64_); - } - if (unpackedFloat_.Count > 0) { - output.WriteFloatArray(100, unpackedFloat_); - } - if (unpackedDouble_.Count > 0) { - output.WriteDoubleArray(101, unpackedDouble_); - } - if (unpackedBool_.Count > 0) { - output.WriteBoolArray(102, unpackedBool_); - } - if (unpackedEnum_.Count > 0) { - output.WriteEnumArray(103, unpackedEnum_); - } + unpackedInt32_.WriteTo(output, _repeated_unpackedInt32_codec); + unpackedInt64_.WriteTo(output, _repeated_unpackedInt64_codec); + unpackedUint32_.WriteTo(output, _repeated_unpackedUint32_codec); + unpackedUint64_.WriteTo(output, _repeated_unpackedUint64_codec); + unpackedSint32_.WriteTo(output, _repeated_unpackedSint32_codec); + unpackedSint64_.WriteTo(output, _repeated_unpackedSint64_codec); + unpackedFixed32_.WriteTo(output, _repeated_unpackedFixed32_codec); + unpackedFixed64_.WriteTo(output, _repeated_unpackedFixed64_codec); + unpackedSfixed32_.WriteTo(output, _repeated_unpackedSfixed32_codec); + unpackedSfixed64_.WriteTo(output, _repeated_unpackedSfixed64_codec); + unpackedFloat_.WriteTo(output, _repeated_unpackedFloat_codec); + unpackedDouble_.WriteTo(output, _repeated_unpackedDouble_codec); + unpackedBool_.WriteTo(output, _repeated_unpackedBool_codec); + unpackedEnum_.WriteTo(output, _repeated_unpackedEnum_codec); } public int CalculateSize() { int size = 0; - if (unpackedInt32_.Count > 0) { - int dataSize = 0; - foreach (int element in unpackedInt32_) { - dataSize += pb::CodedOutputStream.ComputeInt32Size(element); - } - size += dataSize; - size += 2 * unpackedInt32_.Count; - } - if (unpackedInt64_.Count > 0) { - int dataSize = 0; - foreach (long element in unpackedInt64_) { - dataSize += pb::CodedOutputStream.ComputeInt64Size(element); - } - size += dataSize; - size += 2 * unpackedInt64_.Count; - } - if (unpackedUint32_.Count > 0) { - int dataSize = 0; - foreach (uint element in unpackedUint32_) { - dataSize += pb::CodedOutputStream.ComputeUInt32Size(element); - } - size += dataSize; - size += 2 * unpackedUint32_.Count; - } - if (unpackedUint64_.Count > 0) { - int dataSize = 0; - foreach (ulong element in unpackedUint64_) { - dataSize += pb::CodedOutputStream.ComputeUInt64Size(element); - } - size += dataSize; - size += 2 * unpackedUint64_.Count; - } - if (unpackedSint32_.Count > 0) { - int dataSize = 0; - foreach (int element in unpackedSint32_) { - dataSize += pb::CodedOutputStream.ComputeSInt32Size(element); - } - size += dataSize; - size += 2 * unpackedSint32_.Count; - } - if (unpackedSint64_.Count > 0) { - int dataSize = 0; - foreach (long element in unpackedSint64_) { - dataSize += pb::CodedOutputStream.ComputeSInt64Size(element); - } - size += dataSize; - size += 2 * unpackedSint64_.Count; - } - if (unpackedFixed32_.Count > 0) { - int dataSize = 0; - dataSize = 4 * unpackedFixed32_.Count; - size += dataSize; - size += 2 * unpackedFixed32_.Count; - } - if (unpackedFixed64_.Count > 0) { - int dataSize = 0; - dataSize = 8 * unpackedFixed64_.Count; - size += dataSize; - size += 2 * unpackedFixed64_.Count; - } - if (unpackedSfixed32_.Count > 0) { - int dataSize = 0; - dataSize = 4 * unpackedSfixed32_.Count; - size += dataSize; - size += 2 * unpackedSfixed32_.Count; - } - if (unpackedSfixed64_.Count > 0) { - int dataSize = 0; - dataSize = 8 * unpackedSfixed64_.Count; - size += dataSize; - size += 2 * unpackedSfixed64_.Count; - } - if (unpackedFloat_.Count > 0) { - int dataSize = 0; - dataSize = 4 * unpackedFloat_.Count; - size += dataSize; - size += 2 * unpackedFloat_.Count; - } - if (unpackedDouble_.Count > 0) { - int dataSize = 0; - dataSize = 8 * unpackedDouble_.Count; - size += dataSize; - size += 2 * unpackedDouble_.Count; - } - if (unpackedBool_.Count > 0) { - int dataSize = 0; - dataSize = 1 * unpackedBool_.Count; - size += dataSize; - size += 2 * unpackedBool_.Count; - } - if (unpackedEnum_.Count > 0) { - int dataSize = 0; - foreach (global::Google.Protobuf.TestProtos.ForeignEnum element in unpackedEnum_) { - dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); - } - size += dataSize; - size += 2 * unpackedEnum_.Count; - } + size += unpackedInt32_.CalculateSize(_repeated_unpackedInt32_codec); + size += unpackedInt64_.CalculateSize(_repeated_unpackedInt64_codec); + size += unpackedUint32_.CalculateSize(_repeated_unpackedUint32_codec); + size += unpackedUint64_.CalculateSize(_repeated_unpackedUint64_codec); + size += unpackedSint32_.CalculateSize(_repeated_unpackedSint32_codec); + size += unpackedSint64_.CalculateSize(_repeated_unpackedSint64_codec); + size += unpackedFixed32_.CalculateSize(_repeated_unpackedFixed32_codec); + size += unpackedFixed64_.CalculateSize(_repeated_unpackedFixed64_codec); + size += unpackedSfixed32_.CalculateSize(_repeated_unpackedSfixed32_codec); + size += unpackedSfixed64_.CalculateSize(_repeated_unpackedSfixed64_codec); + size += unpackedFloat_.CalculateSize(_repeated_unpackedFloat_codec); + size += unpackedDouble_.CalculateSize(_repeated_unpackedDouble_codec); + size += unpackedBool_.CalculateSize(_repeated_unpackedBool_codec); + size += unpackedEnum_.CalculateSize(_repeated_unpackedEnum_codec); return size; } @@ -5902,72 +5526,72 @@ namespace Google.Protobuf.TestProtos { break; case 722: case 720: { - input.ReadInt32Array(unpackedInt32_); + unpackedInt32_.AddEntriesFrom(input, _repeated_unpackedInt32_codec); break; } case 730: case 728: { - input.ReadInt64Array(unpackedInt64_); + unpackedInt64_.AddEntriesFrom(input, _repeated_unpackedInt64_codec); break; } case 738: case 736: { - input.ReadUInt32Array(unpackedUint32_); + unpackedUint32_.AddEntriesFrom(input, _repeated_unpackedUint32_codec); break; } case 746: case 744: { - input.ReadUInt64Array(unpackedUint64_); + unpackedUint64_.AddEntriesFrom(input, _repeated_unpackedUint64_codec); break; } case 754: case 752: { - input.ReadSInt32Array(unpackedSint32_); + unpackedSint32_.AddEntriesFrom(input, _repeated_unpackedSint32_codec); break; } case 762: case 760: { - input.ReadSInt64Array(unpackedSint64_); + unpackedSint64_.AddEntriesFrom(input, _repeated_unpackedSint64_codec); break; } case 770: case 773: { - input.ReadFixed32Array(unpackedFixed32_); + unpackedFixed32_.AddEntriesFrom(input, _repeated_unpackedFixed32_codec); break; } case 778: case 777: { - input.ReadFixed64Array(unpackedFixed64_); + unpackedFixed64_.AddEntriesFrom(input, _repeated_unpackedFixed64_codec); break; } case 786: case 789: { - input.ReadSFixed32Array(unpackedSfixed32_); + unpackedSfixed32_.AddEntriesFrom(input, _repeated_unpackedSfixed32_codec); break; } case 794: case 793: { - input.ReadSFixed64Array(unpackedSfixed64_); + unpackedSfixed64_.AddEntriesFrom(input, _repeated_unpackedSfixed64_codec); break; } case 802: case 805: { - input.ReadFloatArray(unpackedFloat_); + unpackedFloat_.AddEntriesFrom(input, _repeated_unpackedFloat_codec); break; } case 810: case 809: { - input.ReadDoubleArray(unpackedDouble_); + unpackedDouble_.AddEntriesFrom(input, _repeated_unpackedDouble_codec); break; } case 818: case 816: { - input.ReadBoolArray(unpackedBool_); + unpackedBool_.AddEntriesFrom(input, _repeated_unpackedBool_codec); break; } case 826: case 824: { - input.ReadEnumArray<global::Google.Protobuf.TestProtos.ForeignEnum>(unpackedEnum_); + unpackedEnum_.AddEntriesFrom(input, _repeated_unpackedEnum_codec); break; } } @@ -6023,36 +5647,48 @@ namespace Google.Protobuf.TestProtos { } public const int RepeatedFixed32FieldNumber = 12; + private static readonly pb::FieldCodec<uint> _repeated_repeatedFixed32_codec + = pb::FieldCodec.ForFixed32(98); private readonly pbc::RepeatedField<uint> repeatedFixed32_ = new pbc::RepeatedField<uint>(); public pbc::RepeatedField<uint> RepeatedFixed32 { get { return repeatedFixed32_; } } public const int RepeatedInt32FieldNumber = 13; + private static readonly pb::FieldCodec<int> _repeated_repeatedInt32_codec + = pb::FieldCodec.ForInt32(106); private readonly pbc::RepeatedField<int> repeatedInt32_ = new pbc::RepeatedField<int>(); public pbc::RepeatedField<int> RepeatedInt32 { get { return repeatedInt32_; } } public const int RepeatedFixed64FieldNumber = 2046; + private static readonly pb::FieldCodec<ulong> _repeated_repeatedFixed64_codec + = pb::FieldCodec.ForFixed64(16370); private readonly pbc::RepeatedField<ulong> repeatedFixed64_ = new pbc::RepeatedField<ulong>(); public pbc::RepeatedField<ulong> RepeatedFixed64 { get { return repeatedFixed64_; } } public const int RepeatedInt64FieldNumber = 2047; + private static readonly pb::FieldCodec<long> _repeated_repeatedInt64_codec + = pb::FieldCodec.ForInt64(16378); private readonly pbc::RepeatedField<long> repeatedInt64_ = new pbc::RepeatedField<long>(); public pbc::RepeatedField<long> RepeatedInt64 { get { return repeatedInt64_; } } public const int RepeatedFloatFieldNumber = 262142; + private static readonly pb::FieldCodec<float> _repeated_repeatedFloat_codec + = pb::FieldCodec.ForFloat(2097138); private readonly pbc::RepeatedField<float> repeatedFloat_ = new pbc::RepeatedField<float>(); public pbc::RepeatedField<float> RepeatedFloat { get { return repeatedFloat_; } } public const int RepeatedUint64FieldNumber = 262143; + private static readonly pb::FieldCodec<ulong> _repeated_repeatedUint64_codec + = pb::FieldCodec.ForUInt64(2097146); private readonly pbc::RepeatedField<ulong> repeatedUint64_ = new pbc::RepeatedField<ulong>(); public pbc::RepeatedField<ulong> RepeatedUint64 { get { return repeatedUint64_; } @@ -6090,76 +5726,22 @@ namespace Google.Protobuf.TestProtos { } public void WriteTo(pb::CodedOutputStream output) { - if (repeatedFixed32_.Count > 0) { - output.WriteRawTag(98); - output.WritePackedFixed32Array(repeatedFixed32_); - } - if (repeatedInt32_.Count > 0) { - output.WriteRawTag(106); - output.WritePackedInt32Array(repeatedInt32_); - } - if (repeatedFixed64_.Count > 0) { - output.WriteRawTag(242, 127); - output.WritePackedFixed64Array(repeatedFixed64_); - } - if (repeatedInt64_.Count > 0) { - output.WriteRawTag(250, 127); - output.WritePackedInt64Array(repeatedInt64_); - } - if (repeatedFloat_.Count > 0) { - output.WriteRawTag(242, 255, 127); - output.WritePackedFloatArray(repeatedFloat_); - } - if (repeatedUint64_.Count > 0) { - output.WriteRawTag(250, 255, 127); - output.WritePackedUInt64Array(repeatedUint64_); - } + repeatedFixed32_.WriteTo(output, _repeated_repeatedFixed32_codec); + repeatedInt32_.WriteTo(output, _repeated_repeatedInt32_codec); + repeatedFixed64_.WriteTo(output, _repeated_repeatedFixed64_codec); + repeatedInt64_.WriteTo(output, _repeated_repeatedInt64_codec); + repeatedFloat_.WriteTo(output, _repeated_repeatedFloat_codec); + repeatedUint64_.WriteTo(output, _repeated_repeatedUint64_codec); } public int CalculateSize() { int size = 0; - if (repeatedFixed32_.Count > 0) { - int dataSize = 0; - dataSize = 4 * repeatedFixed32_.Count; - size += dataSize; - size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedInt32_.Count > 0) { - int dataSize = 0; - foreach (int element in repeatedInt32_) { - dataSize += pb::CodedOutputStream.ComputeInt32Size(element); - } - size += dataSize; - size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedFixed64_.Count > 0) { - int dataSize = 0; - dataSize = 8 * repeatedFixed64_.Count; - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedInt64_.Count > 0) { - int dataSize = 0; - foreach (long element in repeatedInt64_) { - dataSize += pb::CodedOutputStream.ComputeInt64Size(element); - } - size += dataSize; - size += 2 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedFloat_.Count > 0) { - int dataSize = 0; - dataSize = 4 * repeatedFloat_.Count; - size += dataSize; - size += 3 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } - if (repeatedUint64_.Count > 0) { - int dataSize = 0; - foreach (ulong element in repeatedUint64_) { - dataSize += pb::CodedOutputStream.ComputeUInt64Size(element); - } - size += dataSize; - size += 3 + pb::CodedOutputStream.ComputeInt32Size(dataSize); - } + size += repeatedFixed32_.CalculateSize(_repeated_repeatedFixed32_codec); + size += repeatedInt32_.CalculateSize(_repeated_repeatedInt32_codec); + size += repeatedFixed64_.CalculateSize(_repeated_repeatedFixed64_codec); + size += repeatedInt64_.CalculateSize(_repeated_repeatedInt64_codec); + size += repeatedFloat_.CalculateSize(_repeated_repeatedFloat_codec); + size += repeatedUint64_.CalculateSize(_repeated_repeatedUint64_codec); return size; } @@ -6188,32 +5770,32 @@ namespace Google.Protobuf.TestProtos { break; case 98: case 101: { - input.ReadFixed32Array(repeatedFixed32_); + repeatedFixed32_.AddEntriesFrom(input, _repeated_repeatedFixed32_codec); break; } case 106: case 104: { - input.ReadInt32Array(repeatedInt32_); + repeatedInt32_.AddEntriesFrom(input, _repeated_repeatedInt32_codec); break; } case 16370: case 16369: { - input.ReadFixed64Array(repeatedFixed64_); + repeatedFixed64_.AddEntriesFrom(input, _repeated_repeatedFixed64_codec); break; } case 16378: case 16376: { - input.ReadInt64Array(repeatedInt64_); + repeatedInt64_.AddEntriesFrom(input, _repeated_repeatedInt64_codec); break; } case 2097138: case 2097141: { - input.ReadFloatArray(repeatedFloat_); + repeatedFloat_.AddEntriesFrom(input, _repeated_repeatedFloat_codec); break; } case 2097146: case 2097144: { - input.ReadUInt64Array(repeatedUint64_); + repeatedUint64_.AddEntriesFrom(input, _repeated_repeatedUint64_codec); break; } } |