Skip to content

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

First pass (not yet compiling) at removing all the array handling code from Coded*Stream. 

Prod code works, but some tests are broken. Obviously those need fixing, then more tests,
and review benchmarks.
parent 241e17ba
Show whitespace changes
Inline Side-by-side
Showing with 689 additions and 1916 deletions
csharp/src/AddressBook/Addressbook.cs
View file @ f2a27cc2
......@@ -131,6 +131,8 @@ namespace Google.Protobuf.Examples.AddressBook {
}
public const int PhoneFieldNumber = 4;
private static readonly pb::FieldCodec<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber> _repeated_phone_codec
= pb::FieldCodec.ForMessage(34, global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber> phone_ = new pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber>();
public pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber> Phone {
get { return phone_; }
......@@ -176,9 +178,7 @@ namespace Google.Protobuf.Examples.AddressBook {
output.WriteRawTag(26);
output.WriteString(Email);
}
if (phone_.Count > 0) {
output.WriteMessageArray(4, phone_);
}
phone_.WriteTo(output, _repeated_phone_codec);
}
public int CalculateSize() {
......@@ -192,12 +192,7 @@ namespace Google.Protobuf.Examples.AddressBook {
if (Email.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Email);
}
if (phone_.Count > 0) {
foreach (global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber element in phone_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * phone_.Count;
}
size += phone_.CalculateSize(_repeated_phone_codec);
return size;
}
......@@ -241,7 +236,7 @@ namespace Google.Protobuf.Examples.AddressBook {
break;
}
case 34: {
input.ReadMessageArray(phone_, global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber.Parser);
phone_.AddEntriesFrom(input, _repeated_phone_codec);
break;
}
}
......@@ -437,6 +432,8 @@ namespace Google.Protobuf.Examples.AddressBook {
}
public const int PersonFieldNumber = 1;
private static readonly pb::FieldCodec<global::Google.Protobuf.Examples.AddressBook.Person> _repeated_person_codec
= pb::FieldCodec.ForMessage(10, global::Google.Protobuf.Examples.AddressBook.Person.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person> person_ = new pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person>();
public pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person> Person {
get { return person_; }
......@@ -464,19 +461,12 @@ namespace Google.Protobuf.Examples.AddressBook {
}
public void WriteTo(pb::CodedOutputStream output) {
if (person_.Count > 0) {
output.WriteMessageArray(1, person_);
}
person_.WriteTo(output, _repeated_person_codec);
}
public int CalculateSize() {
int size = 0;
if (person_.Count > 0) {
foreach (global::Google.Protobuf.Examples.AddressBook.Person element in person_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * person_.Count;
}
size += person_.CalculateSize(_repeated_person_codec);
return size;
}
......@@ -499,7 +489,7 @@ namespace Google.Protobuf.Examples.AddressBook {
}
break;
case 10: {
input.ReadMessageArray(person_, global::Google.Protobuf.Examples.AddressBook.Person.Parser);
person_.AddEntriesFrom(input, _repeated_person_codec);
break;
}
}
......
csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs
View file @ f2a27cc2
......@@ -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;
}
}
......
csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs
View file @ f2a27cc2
......@@ -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;
}
}
......
csharp/src/ProtocolBuffers/CodedInputStream.cs
View file @ f2a27cc2
......@@ -172,6 +172,12 @@ namespace Google.Protobuf
}
}
/// <summary>
/// Returns the last tag read, or 0 if no tags have been read or we've read beyond
/// the end of the stream.
/// </summary>
internal uint LastTag { get { return lastTag; } }
#region Validation
/// <summary>
......@@ -435,26 +441,6 @@ namespace Google.Protobuf
return DecodeZigZag64(ReadRawVarint64());
}
private bool BeginArray(uint fieldTag, out bool isPacked, out int oldLimit)
{
isPacked = WireFormat.GetTagWireType(fieldTag) == WireFormat.WireType.LengthDelimited;
if (isPacked)
{
int length = (int) (ReadRawVarint32() & int.MaxValue);
if (length > 0)
{
oldLimit = PushLimit(length);
return true;
}
oldLimit = -1;
return false; //packed but empty
}
oldLimit = -1;
return true;
}
/// <summary>
/// Peeks at the next tag in the stream. If it matches <paramref name="tag"/>,
/// the tag is consumed and the method returns <c>true</c>; otherwise, the
......@@ -474,268 +460,6 @@ namespace Google.Protobuf
return false;
}
/// <summary>
/// Returns true if the next tag is also part of the same array, which may or may not be packed.
/// </summary>
private bool ContinueArray(uint currentTag, bool packed, int oldLimit)
{
if (packed)
{
if (ReachedLimit)
{
PopLimit(oldLimit);
return false;
}
return true;
}
return MaybeConsumeTag(currentTag);
}
/// <summary>
/// Reads a string array.
/// </summary>
/// <remarks>The stream is assumed to be positioned after a tag indicating the field
/// repeated string value. A string is read, and then if the next tag is the same,
/// the process is repeated, until the next tag is a different one.</remarks>
/// <param name="list"></param>
public void ReadStringArray(ICollection<string> list)
{
uint fieldTag = lastTag;
do
{
list.Add(ReadString());
} while (MaybeConsumeTag(fieldTag));
}
public void ReadBytesArray(ICollection<ByteString> list)
{
uint fieldTag = lastTag;
do
{
list.Add(ReadBytes());
} while (MaybeConsumeTag(fieldTag));
}
public void ReadBoolArray(ICollection<bool> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadBool());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadInt32Array(ICollection<int> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadInt32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadSInt32Array(ICollection<int> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadSInt32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadUInt32Array(ICollection<uint> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadUInt32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadFixed32Array(ICollection<uint> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadFixed32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadSFixed32Array(ICollection<int> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadSFixed32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadInt64Array(ICollection<long> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadInt64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadSInt64Array(ICollection<long> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadSInt64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadUInt64Array(ICollection<ulong> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadUInt64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadFixed64Array(ICollection<ulong> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadFixed64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadSFixed64Array(ICollection<long> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadSFixed64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadDoubleArray(ICollection<double> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadDouble());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadFloatArray(ICollection<float> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadFloat());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadEnumArray<T>(RepeatedField<T> list)
where T : struct, IComparable, IFormattable
{
uint fieldTag = lastTag;
WireFormat.WireType wformat = WireFormat.GetTagWireType(fieldTag);
// 2.3 allows packed form even if the field is not declared packed.
if (wformat == WireFormat.WireType.LengthDelimited)
{
int length = (int) (ReadRawVarint32() & int.MaxValue);
int limit = PushLimit(length);
while (!ReachedLimit)
{
// Ghastly hack, but it works...
list.AddInt32(ReadEnum());
}
PopLimit(limit);
}
else
{
do
{
list.Add((T)(object) ReadEnum());
} while (MaybeConsumeTag(fieldTag));
}
}
public void ReadMessageArray<T>(ICollection<T> list, MessageParser<T> messageParser)
where T : IMessage<T>
{
uint fieldTag = lastTag;
do
{
T message = messageParser.CreateTemplate();
ReadMessage(message);
list.Add(message);
} while (MaybeConsumeTag(fieldTag));
}
#endregion
#region Underlying reading primitives
......
csharp/src/ProtocolBuffers/CodedOutputStream.cs
View file @ f2a27cc2
......@@ -306,166 +306,6 @@ namespace Google.Protobuf
#endregion
#region Write array members, with fields.
public void WriteMessageArray<T>(int fieldNumber, RepeatedField<T> list)
where T : IMessage
{
foreach (T value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteMessage(value);
}
}
public void WriteStringArray(int fieldNumber, RepeatedField<string> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteString(value);
}
}
public void WriteBytesArray(int fieldNumber, RepeatedField<ByteString> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteBytes(value);
}
}
public void WriteBoolArray(int fieldNumber, RepeatedField<bool> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteBool(value);
}
}
public void WriteInt32Array(int fieldNumber, RepeatedField<int> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteInt32(value);
}
}
public void WriteSInt32Array(int fieldNumber, RepeatedField<int> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteSInt32(value);
}
}
public void WriteUInt32Array(int fieldNumber, RepeatedField<uint> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteUInt32(value);
}
}
public void WriteFixed32Array(int fieldNumber, RepeatedField<uint> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
WriteFixed32(value);
}
}
public void WriteSFixed32Array(int fieldNumber, RepeatedField<int> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
WriteSFixed32(value);
}
}
public void WriteInt64Array(int fieldNumber, RepeatedField<long> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteInt64(value);
}
}
public void WriteSInt64Array(int fieldNumber, RepeatedField<long> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteSInt64(value);
}
}
public void WriteUInt64Array(int fieldNumber, RepeatedField<ulong> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteUInt64(value);
}
}
public void WriteFixed64Array(int fieldNumber, RepeatedField<ulong> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteFixed64(value);
}
}
public void WriteSFixed64Array(int fieldNumber, RepeatedField<long> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteSFixed64(value);
}
}
public void WriteDoubleArray(int fieldNumber, RepeatedField<double> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteDouble(value);
}
}
public void WriteFloatArray(int fieldNumber, RepeatedField<float> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
WriteFloat(value);
}
}
public void WriteEnumArray<T>(int fieldNumber, RepeatedField<T> list)
where T : struct, IComparable, IFormattable
{
// Bit of a hack, to access the values as ints
var iterator = list.GetInt32Enumerator();
while (iterator.MoveNext())
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteEnum(iterator.Current);
}
}
#endregion
#region Raw tag writing
/// <summary>
/// Encodes and writes a tag.
......@@ -534,171 +374,6 @@ namespace Google.Protobuf
}
#endregion
#region Write packed array members
// TODO(jonskeet): A lot of these are really inefficient, due to method group conversions. Fix!
// (Alternatively, add extension methods to RepeatedField, accepting the Write* methods via delegates too.)
public void WritePackedBoolArray(RepeatedField<bool> list)
{
uint size = (uint)list.Count;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteBool(value);
}
}
public void WritePackedInt32Array(RepeatedField<int> list)
{
uint size = list.CalculateSize(ComputeInt32Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteInt32(value);
}
}
public void WritePackedSInt32Array(RepeatedField<int> list)
{
uint size = list.CalculateSize(ComputeSInt32Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteSInt32(value);
}
}
public void WritePackedUInt32Array(RepeatedField<uint> list)
{
uint size = list.CalculateSize(ComputeUInt32Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteUInt32(value);
}
}
public void WritePackedFixed32Array(RepeatedField<uint> list)
{
uint size = (uint) list.Count * 4;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteFixed32(value);
}
}
public void WritePackedSFixed32Array(RepeatedField<int> list)
{
uint size = (uint) list.Count * 4;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteSFixed32(value);
}
}
public void WritePackedInt64Array(RepeatedField<long> list)
{
uint size = list.CalculateSize(ComputeInt64Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteInt64(value);
}
}
public void WritePackedSInt64Array(RepeatedField<long> list)
{
uint size = list.CalculateSize(ComputeSInt64Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteSInt64(value);
}
}
public void WritePackedUInt64Array(RepeatedField<ulong> list)
{
if (list.Count == 0)
{
return;
}
uint size = list.CalculateSize(ComputeUInt64Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteUInt64(value);
}
}
public void WritePackedFixed64Array(RepeatedField<ulong> list)
{
uint size = (uint) list.Count * 8;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteFixed64(value);
}
}
public void WritePackedSFixed64Array(RepeatedField<long> list)
{
uint size = (uint) list.Count * 8;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteSFixed64(value);
}
}
public void WritePackedDoubleArray(RepeatedField<double> list)
{
uint size = (uint) list.Count * 8;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteDouble(value);
}
}
public void WritePackedFloatArray(RepeatedField<float> list)
{
if (list.Count == 0)
{
return;
}
uint size = (uint) list.Count * 4;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteFloat(value);
}
}
public void WritePackedEnumArray<T>(RepeatedField<T> list)
where T : struct, IComparable, IFormattable
{
if (list.Count == 0)
{
return;
}
// Bit of a hack, to access the values as ints
var iterator = list.GetInt32Enumerator();
uint size = 0;
while (iterator.MoveNext())
{
size += (uint) ComputeEnumSize(iterator.Current);
}
iterator.Reset();
WriteRawVarint32(size);
while (iterator.MoveNext())
{
WriteEnum(iterator.Current);
}
}
#endregion
#region Underlying writing primitives
/// <summary>
/// Writes a 32 bit value as a varint. The fast route is taken when
......
csharp/src/ProtocolBuffers/Collections/MapField.cs
View file @ f2a27cc2
......@@ -334,6 +334,10 @@ namespace Google.Protobuf.Collections
public int CalculateSize(Codec codec)
{
if (Count == 0)
{
return 0;
}
var message = new Codec.MessageAdapter(codec);
int size = 0;
foreach (var entry in list)
......@@ -419,13 +423,13 @@ namespace Google.Protobuf.Collections
public void WriteTo(CodedOutputStream output)
{
codec.keyCodec.Write(output, Key);
codec.valueCodec.Write(output, Value);
codec.keyCodec.WriteTagAndValue(output, Key);
codec.valueCodec.WriteTagAndValue(output, Value);
}
public int CalculateSize()
{
return codec.keyCodec.CalculateSize(Key) + codec.valueCodec.CalculateSize(Value);
return codec.keyCodec.CalculateSizeWithTag(Key) + codec.valueCodec.CalculateSizeWithTag(Value);
}
}
}
......
csharp/src/ProtocolBuffers/Collections/RepeatedField.cs
View file @ f2a27cc2
......@@ -49,6 +49,112 @@ namespace Google.Protobuf.Collections
return clone;
}
public void AddEntriesFrom(CodedInputStream input, FieldCodec<T> codec)
{
uint tag = input.LastTag;
var reader = codec.ValueReader;
// Value types can be packed or not.
if (typeof(T).IsValueType && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited)
{
int length = (int)(input.ReadRawVarint32() & int.MaxValue);
if (length > 0)
{
int oldLimit = input.PushLimit(length);
while (!input.ReachedLimit)
{
Add(reader(input));
}
input.PopLimit(oldLimit);
}
// Empty packed field. Odd, but valid - just ignore.
}
else
{
// Not packed... (possibly not packable)
do
{
Add(reader(input));
} while (input.MaybeConsumeTag(tag));
}
}
public int CalculateSize(FieldCodec<T> codec)
{
if (count == 0)
{
return 0;
}
uint tag = codec.Tag;
if (typeof(T).IsValueType && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited)
{
int dataSize = CalculatePackedDataSize(codec);
return CodedOutputStream.ComputeRawVarint32Size(tag) +
CodedOutputStream.ComputeRawVarint32Size((uint)dataSize) +
dataSize;
}
else
{
var sizeCalculator = codec.ValueSizeCalculator;
int size = count * CodedOutputStream.ComputeRawVarint32Size(tag);
for (int i = 0; i < count; i++)
{
size += sizeCalculator(array[i]);
}
return size;
}
}
private int CalculatePackedDataSize(FieldCodec<T> codec)
{
int fixedSize = codec.FixedSize;
if (fixedSize == 0)
{
var calculator = codec.ValueSizeCalculator;
int tmp = 0;
for (int i = 0; i < count; i++)
{
tmp += calculator(array[i]);
}
return tmp;
}
else
{
return fixedSize * Count;
}
}
public void WriteTo(CodedOutputStream output, FieldCodec<T> codec)
{
// TODO: Assert that T is a value type, and that codec.Tag is packed?
if (count == 0)
{
return;
}
var writer = codec.ValueWriter;
var tag = codec.Tag;
if (typeof(T).IsValueType && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited)
{
// Packed primitive type
uint size = (uint)CalculatePackedDataSize(codec);
output.WriteTag(tag);
output.WriteRawVarint32(size);
for (int i = 0; i < count; i++)
{
writer(output, array[i]);
}
}
else
{
// Not packed: a simple tag/value pair for each value.
// Can't use codec.WriteTagAndValue, as that omits default values.
for (int i = 0; i < count; i++)
{
output.WriteTag(tag);
writer(output, array[i]);
}
}
}
public bool IsFrozen { get { return frozen; } }
public void Freeze()
......@@ -87,18 +193,6 @@ namespace Google.Protobuf.Collections
array[count++] = item;
}
/// <summary>
/// Hack to allow us to add enums easily... will only work with int-based types.
/// </summary>
/// <param name="readEnum"></param>
internal void AddInt32(int item)
{
this.CheckMutable();
EnsureSize(count + 1);
int[] castArray = (int[]) (object) array;
castArray[count++] = item;
}
public void Clear()
{
this.CheckMutable();
......@@ -182,15 +276,6 @@ namespace Google.Protobuf.Collections
return GetEnumerator();
}
/// <summary>
/// Returns an enumerator of the values in this list as integers.
/// Used for enum types.
/// </summary>
internal Int32Enumerator GetInt32Enumerator()
{
return new Int32Enumerator((int[])(object)array, count);
}
public override int GetHashCode()
{
int hash = 0;
......@@ -298,16 +383,6 @@ namespace Google.Protobuf.Collections
}
}
internal uint CalculateSize(Func<T, int> sizeComputer)
{
int size = 0;
for (int i = 0; i < count; i++)
{
size += sizeComputer(array[i]);
}
return (uint)size;
}
public struct Enumerator : IEnumerator<T>
{
private int index;
......@@ -355,46 +430,5 @@ namespace Google.Protobuf.Collections
{
}
}
internal struct Int32Enumerator : IEnumerator<int>
{
private int index;
private readonly int[] array;
private readonly int count;
public Int32Enumerator(int[] array, int count)
{
this.array = array;
this.index = -1;
this.count = count;
}
public bool MoveNext()
{
if (index + 1 >= count)
{
return false;
}
index++;
return true;
}
public void Reset()
{
index = -1;
}
// No guard here, as we're only going to use this internally...
public int Current { get { return array[index]; } }
object IEnumerator.Current
{
get { return Current; }
}
public void Dispose()
{
}
}
}
}
csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
View file @ f2a27cc2
......@@ -314,6 +314,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int FileFieldNumber = 1;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto> _repeated_file_codec
= pb::FieldCodec.ForMessage(10, global::Google.Protobuf.DescriptorProtos.FileDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto> file_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto> File {
get { return file_; }
......@@ -341,19 +343,12 @@ namespace Google.Protobuf.DescriptorProtos {
}
public void WriteTo(pb::CodedOutputStream output) {
if (file_.Count > 0) {
output.WriteMessageArray(1, file_);
}
file_.WriteTo(output, _repeated_file_codec);
}
public int CalculateSize() {
int size = 0;
if (file_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.FileDescriptorProto element in file_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * file_.Count;
}
size += file_.CalculateSize(_repeated_file_codec);
return size;
}
......@@ -376,7 +371,7 @@ namespace Google.Protobuf.DescriptorProtos {
}
break;
case 10: {
input.ReadMessageArray(file_, global::Google.Protobuf.DescriptorProtos.FileDescriptorProto.Parser);
file_.AddEntriesFrom(input, _repeated_file_codec);
break;
}
}
......@@ -461,42 +456,56 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int DependencyFieldNumber = 3;
private static readonly pb::FieldCodec<string> _repeated_dependency_codec
= pb::FieldCodec.ForString(26);
private readonly pbc::RepeatedField<string> dependency_ = new pbc::RepeatedField<string>();
public pbc::RepeatedField<string> Dependency {
get { return dependency_; }
}
public const int PublicDependencyFieldNumber = 10;
private static readonly pb::FieldCodec<int> _repeated_publicDependency_codec
= pb::FieldCodec.ForInt32(80);
private readonly pbc::RepeatedField<int> publicDependency_ = new pbc::RepeatedField<int>();
public pbc::RepeatedField<int> PublicDependency {
get { return publicDependency_; }
}
public const int WeakDependencyFieldNumber = 11;
private static readonly pb::FieldCodec<int> _repeated_weakDependency_codec
= pb::FieldCodec.ForInt32(88);
private readonly pbc::RepeatedField<int> weakDependency_ = new pbc::RepeatedField<int>();
public pbc::RepeatedField<int> WeakDependency {
get { return weakDependency_; }
}
public const int MessageTypeFieldNumber = 4;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto> _repeated_messageType_codec
= pb::FieldCodec.ForMessage(34, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> messageType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> MessageType {
get { return messageType_; }
}
public const int EnumTypeFieldNumber = 5;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> _repeated_enumType_codec
= pb::FieldCodec.ForMessage(42, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> EnumType {
get { return enumType_; }
}
public const int ServiceFieldNumber = 6;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto> _repeated_service_codec
= pb::FieldCodec.ForMessage(50, global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto> service_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto> Service {
get { return service_; }
}
public const int ExtensionFieldNumber = 7;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> _repeated_extension_codec
= pb::FieldCodec.ForMessage(58, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> Extension {
get { return extension_; }
......@@ -584,21 +593,11 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(18);
output.WriteString(Package);
}
if (dependency_.Count > 0) {
output.WriteStringArray(3, dependency_);
}
if (messageType_.Count > 0) {
output.WriteMessageArray(4, messageType_);
}
if (enumType_.Count > 0) {
output.WriteMessageArray(5, enumType_);
}
if (service_.Count > 0) {
output.WriteMessageArray(6, service_);
}
if (extension_.Count > 0) {
output.WriteMessageArray(7, extension_);
}
dependency_.WriteTo(output, _repeated_dependency_codec);
messageType_.WriteTo(output, _repeated_messageType_codec);
enumType_.WriteTo(output, _repeated_enumType_codec);
service_.WriteTo(output, _repeated_service_codec);
extension_.WriteTo(output, _repeated_extension_codec);
if (options_ != null) {
output.WriteRawTag(66);
output.WriteMessage(Options);
......@@ -607,12 +606,8 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(74);
output.WriteMessage(SourceCodeInfo);
}
if (publicDependency_.Count > 0) {
output.WriteInt32Array(10, publicDependency_);
}
if (weakDependency_.Count > 0) {
output.WriteInt32Array(11, weakDependency_);
}
publicDependency_.WriteTo(output, _repeated_publicDependency_codec);
weakDependency_.WriteTo(output, _repeated_weakDependency_codec);
if (Syntax.Length != 0) {
output.WriteRawTag(98);
output.WriteString(Syntax);
......@@ -627,54 +622,13 @@ namespace Google.Protobuf.DescriptorProtos {
if (Package.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Package);
}
if (dependency_.Count > 0) {
int dataSize = 0;
foreach (string element in dependency_) {
dataSize += pb::CodedOutputStream.ComputeStringSize(element);
}
size += dataSize;
size += 1 * dependency_.Count;
}
if (publicDependency_.Count > 0) {
int dataSize = 0;
foreach (int element in publicDependency_) {
dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
}
size += dataSize;
size += 1 * publicDependency_.Count;
}
if (weakDependency_.Count > 0) {
int dataSize = 0;
foreach (int element in weakDependency_) {
dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
}
size += dataSize;
size += 1 * weakDependency_.Count;
}
if (messageType_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto element in messageType_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * messageType_.Count;
}
if (enumType_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto element in enumType_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * enumType_.Count;
}
if (service_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto element in service_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * service_.Count;
}
if (extension_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto element in extension_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * extension_.Count;
}
size += dependency_.CalculateSize(_repeated_dependency_codec);
size += publicDependency_.CalculateSize(_repeated_publicDependency_codec);
size += weakDependency_.CalculateSize(_repeated_weakDependency_codec);
size += messageType_.CalculateSize(_repeated_messageType_codec);
size += enumType_.CalculateSize(_repeated_enumType_codec);
size += service_.CalculateSize(_repeated_service_codec);
size += extension_.CalculateSize(_repeated_extension_codec);
if (options_ != null) {
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
}
......@@ -741,23 +695,23 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 26: {
input.ReadStringArray(dependency_);
dependency_.AddEntriesFrom(input, _repeated_dependency_codec);
break;
}
case 34: {
input.ReadMessageArray(messageType_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
messageType_.AddEntriesFrom(input, _repeated_messageType_codec);
break;
}
case 42: {
input.ReadMessageArray(enumType_, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
enumType_.AddEntriesFrom(input, _repeated_enumType_codec);
break;
}
case 50: {
input.ReadMessageArray(service_, global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto.Parser);
service_.AddEntriesFrom(input, _repeated_service_codec);
break;
}
case 58: {
input.ReadMessageArray(extension_, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
extension_.AddEntriesFrom(input, _repeated_extension_codec);
break;
}
case 66: {
......@@ -776,12 +730,12 @@ namespace Google.Protobuf.DescriptorProtos {
}
case 82:
case 80: {
input.ReadInt32Array(publicDependency_);
publicDependency_.AddEntriesFrom(input, _repeated_publicDependency_codec);
break;
}
case 90:
case 88: {
input.ReadInt32Array(weakDependency_);
weakDependency_.AddEntriesFrom(input, _repeated_weakDependency_codec);
break;
}
case 98: {
......@@ -858,36 +812,48 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int FieldFieldNumber = 2;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> _repeated_field_codec
= pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> field_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> Field {
get { return field_; }
}
public const int ExtensionFieldNumber = 6;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> _repeated_extension_codec
= pb::FieldCodec.ForMessage(50, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> Extension {
get { return extension_; }
}
public const int NestedTypeFieldNumber = 3;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto> _repeated_nestedType_codec
= pb::FieldCodec.ForMessage(26, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> nestedType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> NestedType {
get { return nestedType_; }
}
public const int EnumTypeFieldNumber = 4;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> _repeated_enumType_codec
= pb::FieldCodec.ForMessage(34, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> EnumType {
get { return enumType_; }
}
public const int ExtensionRangeFieldNumber = 5;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange> _repeated_extensionRange_codec
= pb::FieldCodec.ForMessage(42, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange> extensionRange_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange> ExtensionRange {
get { return extensionRange_; }
}
public const int OneofDeclFieldNumber = 8;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto> _repeated_oneofDecl_codec
= pb::FieldCodec.ForMessage(66, global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto> oneofDecl_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto> OneofDecl {
get { return oneofDecl_; }
......@@ -904,12 +870,16 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int ReservedRangeFieldNumber = 9;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange> _repeated_reservedRange_codec
= pb::FieldCodec.ForMessage(74, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange> reservedRange_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange> ReservedRange {
get { return reservedRange_; }
}
public const int ReservedNameFieldNumber = 10;
private static readonly pb::FieldCodec<string> _repeated_reservedName_codec
= pb::FieldCodec.ForString(82);
private readonly pbc::RepeatedField<string> reservedName_ = new pbc::RepeatedField<string>();
public pbc::RepeatedField<string> ReservedName {
get { return reservedName_; }
......@@ -959,34 +929,18 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(10);
output.WriteString(Name);
}
if (field_.Count > 0) {
output.WriteMessageArray(2, field_);
}
if (nestedType_.Count > 0) {
output.WriteMessageArray(3, nestedType_);
}
if (enumType_.Count > 0) {
output.WriteMessageArray(4, enumType_);
}
if (extensionRange_.Count > 0) {
output.WriteMessageArray(5, extensionRange_);
}
if (extension_.Count > 0) {
output.WriteMessageArray(6, extension_);
}
field_.WriteTo(output, _repeated_field_codec);
nestedType_.WriteTo(output, _repeated_nestedType_codec);
enumType_.WriteTo(output, _repeated_enumType_codec);
extensionRange_.WriteTo(output, _repeated_extensionRange_codec);
extension_.WriteTo(output, _repeated_extension_codec);
if (options_ != null) {
output.WriteRawTag(58);
output.WriteMessage(Options);
}
if (oneofDecl_.Count > 0) {
output.WriteMessageArray(8, oneofDecl_);
}
if (reservedRange_.Count > 0) {
output.WriteMessageArray(9, reservedRange_);
}
if (reservedName_.Count > 0) {
output.WriteStringArray(10, reservedName_);
}
oneofDecl_.WriteTo(output, _repeated_oneofDecl_codec);
reservedRange_.WriteTo(output, _repeated_reservedRange_codec);
reservedName_.WriteTo(output, _repeated_reservedName_codec);
}
public int CalculateSize() {
......@@ -994,59 +948,17 @@ namespace Google.Protobuf.DescriptorProtos {
if (Name.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
}
if (field_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto element in field_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * field_.Count;
}
if (extension_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto element in extension_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * extension_.Count;
}
if (nestedType_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto element in nestedType_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * nestedType_.Count;
}
if (enumType_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto element in enumType_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * enumType_.Count;
}
if (extensionRange_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange element in extensionRange_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * extensionRange_.Count;
}
if (oneofDecl_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto element in oneofDecl_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * oneofDecl_.Count;
}
size += field_.CalculateSize(_repeated_field_codec);
size += extension_.CalculateSize(_repeated_extension_codec);
size += nestedType_.CalculateSize(_repeated_nestedType_codec);
size += enumType_.CalculateSize(_repeated_enumType_codec);
size += extensionRange_.CalculateSize(_repeated_extensionRange_codec);
size += oneofDecl_.CalculateSize(_repeated_oneofDecl_codec);
if (options_ != null) {
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
}
if (reservedRange_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange element in reservedRange_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * reservedRange_.Count;
}
if (reservedName_.Count > 0) {
int dataSize = 0;
foreach (string element in reservedName_) {
dataSize += pb::CodedOutputStream.ComputeStringSize(element);
}
size += dataSize;
size += 1 * reservedName_.Count;
}
size += reservedRange_.CalculateSize(_repeated_reservedRange_codec);
size += reservedName_.CalculateSize(_repeated_reservedName_codec);
return size;
}
......@@ -1089,23 +1001,23 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 18: {
input.ReadMessageArray(field_, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
field_.AddEntriesFrom(input, _repeated_field_codec);
break;
}
case 26: {
input.ReadMessageArray(nestedType_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
nestedType_.AddEntriesFrom(input, _repeated_nestedType_codec);
break;
}
case 34: {
input.ReadMessageArray(enumType_, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
enumType_.AddEntriesFrom(input, _repeated_enumType_codec);
break;
}
case 42: {
input.ReadMessageArray(extensionRange_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Parser);
extensionRange_.AddEntriesFrom(input, _repeated_extensionRange_codec);
break;
}
case 50: {
input.ReadMessageArray(extension_, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
extension_.AddEntriesFrom(input, _repeated_extension_codec);
break;
}
case 58: {
......@@ -1116,15 +1028,15 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 66: {
input.ReadMessageArray(oneofDecl_, global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto.Parser);
oneofDecl_.AddEntriesFrom(input, _repeated_oneofDecl_codec);
break;
}
case 74: {
input.ReadMessageArray(reservedRange_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange.Parser);
reservedRange_.AddEntriesFrom(input, _repeated_reservedRange_codec);
break;
}
case 82: {
input.ReadStringArray(reservedName_);
reservedName_.AddEntriesFrom(input, _repeated_reservedName_codec);
break;
}
}
......@@ -1943,6 +1855,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int ValueFieldNumber = 2;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto> _repeated_value_codec
= pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto> value_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto> Value {
get { return value_; }
......@@ -1988,9 +1902,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(10);
output.WriteString(Name);
}
if (value_.Count > 0) {
output.WriteMessageArray(2, value_);
}
value_.WriteTo(output, _repeated_value_codec);
if (options_ != null) {
output.WriteRawTag(26);
output.WriteMessage(Options);
......@@ -2002,12 +1914,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Name.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
}
if (value_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto element in value_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * value_.Count;
}
size += value_.CalculateSize(_repeated_value_codec);
if (options_ != null) {
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
}
......@@ -2046,7 +1953,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 18: {
input.ReadMessageArray(value_, global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto.Parser);
value_.AddEntriesFrom(input, _repeated_value_codec);
break;
}
case 26: {
......@@ -2284,6 +2191,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int MethodFieldNumber = 2;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto> _repeated_method_codec
= pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto> method_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto> Method {
get { return method_; }
......@@ -2329,9 +2238,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(10);
output.WriteString(Name);
}
if (method_.Count > 0) {
output.WriteMessageArray(2, method_);
}
method_.WriteTo(output, _repeated_method_codec);
if (options_ != null) {
output.WriteRawTag(26);
output.WriteMessage(Options);
......@@ -2343,12 +2250,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Name.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
}
if (method_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto element in method_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * method_.Count;
}
size += method_.CalculateSize(_repeated_method_codec);
if (options_ != null) {
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
}
......@@ -2387,7 +2289,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 18: {
input.ReadMessageArray(method_, global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto.Parser);
method_.AddEntriesFrom(input, _repeated_method_codec);
break;
}
case 26: {
......@@ -2847,6 +2749,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
......@@ -2958,9 +2862,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(170, 2);
output.WriteString(CsharpNamespace);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
......@@ -3007,12 +2909,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (CsharpNamespace.Length != 0) {
size += 2 + pb::CodedOutputStream.ComputeStringSize(CsharpNamespace);
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
......@@ -3133,7 +3030,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
......@@ -3235,6 +3132,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
......@@ -3286,9 +3185,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(56);
output.WriteBool(MapEntry);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
......@@ -3305,12 +3202,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (MapEntry != false) {
size += 1 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
......@@ -3361,7 +3253,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
......@@ -3473,6 +3365,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
......@@ -3536,9 +3430,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(80);
output.WriteBool(Weak);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
......@@ -3561,12 +3453,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Weak != false) {
size += 1 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
......@@ -3631,7 +3518,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
......@@ -3717,6 +3604,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
......@@ -3756,9 +3645,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(24);
output.WriteBool(Deprecated);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
......@@ -3769,12 +3656,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Deprecated != false) {
size += 1 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
......@@ -3811,7 +3693,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
......@@ -3868,6 +3750,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
......@@ -3901,9 +3785,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(8);
output.WriteBool(Deprecated);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
......@@ -3911,12 +3793,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Deprecated != false) {
size += 1 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
......@@ -3946,7 +3823,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
......@@ -4003,6 +3880,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
......@@ -4036,9 +3915,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(136, 2);
output.WriteBool(Deprecated);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
......@@ -4046,12 +3923,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Deprecated != false) {
size += 2 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
......@@ -4081,7 +3953,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
......@@ -4138,6 +4010,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
......@@ -4171,9 +4045,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(136, 2);
output.WriteBool(Deprecated);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
......@@ -4181,12 +4053,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Deprecated != false) {
size += 2 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
......@@ -4216,7 +4083,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
......@@ -4268,6 +4135,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int NameFieldNumber = 2;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart> _repeated_name_codec
= pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart> name_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart> Name {
get { return name_; }
......@@ -4367,9 +4236,7 @@ namespace Google.Protobuf.DescriptorProtos {
}
public void WriteTo(pb::CodedOutputStream output) {
if (name_.Count > 0) {
output.WriteMessageArray(2, name_);
}
name_.WriteTo(output, _repeated_name_codec);
if (IdentifierValue.Length != 0) {
output.WriteRawTag(26);
output.WriteString(IdentifierValue);
......@@ -4398,12 +4265,7 @@ namespace Google.Protobuf.DescriptorProtos {
public int CalculateSize() {
int size = 0;
if (name_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart element in name_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * name_.Count;
}
size += name_.CalculateSize(_repeated_name_codec);
if (IdentifierValue.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(IdentifierValue);
}
......@@ -4462,7 +4324,7 @@ namespace Google.Protobuf.DescriptorProtos {
}
break;
case 18: {
input.ReadMessageArray(name_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart.Parser);
name_.AddEntriesFrom(input, _repeated_name_codec);
break;
}
case 26: {
......@@ -4676,6 +4538,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int LocationFieldNumber = 1;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location> _repeated_location_codec
= pb::FieldCodec.ForMessage(10, global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location> location_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location> Location {
get { return location_; }
......@@ -4703,19 +4567,12 @@ namespace Google.Protobuf.DescriptorProtos {
}
public void WriteTo(pb::CodedOutputStream output) {
if (location_.Count > 0) {
output.WriteMessageArray(1, location_);
}
location_.WriteTo(output, _repeated_location_codec);
}
public int CalculateSize() {
int size = 0;
if (location_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location element in location_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * location_.Count;
}
size += location_.CalculateSize(_repeated_location_codec);
return size;
}
......@@ -4738,7 +4595,7 @@ namespace Google.Protobuf.DescriptorProtos {
}
break;
case 10: {
input.ReadMessageArray(location_, global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location.Parser);
location_.AddEntriesFrom(input, _repeated_location_codec);
break;
}
}
......@@ -4791,12 +4648,16 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int PathFieldNumber = 1;
private static readonly pb::FieldCodec<int> _repeated_path_codec
= pb::FieldCodec.ForInt32(10);
private readonly pbc::RepeatedField<int> path_ = new pbc::RepeatedField<int>();
public pbc::RepeatedField<int> Path {
get { return path_; }
}
public const int SpanFieldNumber = 2;
private static readonly pb::FieldCodec<int> _repeated_span_codec
= pb::FieldCodec.ForInt32(18);
private readonly pbc::RepeatedField<int> span_ = new pbc::RepeatedField<int>();
public pbc::RepeatedField<int> Span {
get { return span_; }
......@@ -4823,6 +4684,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int LeadingDetachedCommentsFieldNumber = 6;
private static readonly pb::FieldCodec<string> _repeated_leadingDetachedComments_codec
= pb::FieldCodec.ForString(50);
private readonly pbc::RepeatedField<string> leadingDetachedComments_ = new pbc::RepeatedField<string>();
public pbc::RepeatedField<string> LeadingDetachedComments {
get { return leadingDetachedComments_; }
......@@ -4858,14 +4721,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public void WriteTo(pb::CodedOutputStream output) {
if (path_.Count > 0) {
output.WriteRawTag(10);
output.WritePackedInt32Array(path_);
}
if (span_.Count > 0) {
output.WriteRawTag(18);
output.WritePackedInt32Array(span_);
}
path_.WriteTo(output, _repeated_path_codec);
span_.WriteTo(output, _repeated_span_codec);
if (LeadingComments.Length != 0) {
output.WriteRawTag(26);
output.WriteString(LeadingComments);
......@@ -4874,43 +4731,20 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(34);
output.WriteString(TrailingComments);
}
if (leadingDetachedComments_.Count > 0) {
output.WriteStringArray(6, leadingDetachedComments_);
}
leadingDetachedComments_.WriteTo(output, _repeated_leadingDetachedComments_codec);
}
public int CalculateSize() {
int size = 0;
if (path_.Count > 0) {
int dataSize = 0;
foreach (int element in path_) {
dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
}
size += dataSize;
size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
}
if (span_.Count > 0) {
int dataSize = 0;
foreach (int element in span_) {
dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
}
size += dataSize;
size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
}
size += path_.CalculateSize(_repeated_path_codec);
size += span_.CalculateSize(_repeated_span_codec);
if (LeadingComments.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(LeadingComments);
}
if (TrailingComments.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(TrailingComments);
}
if (leadingDetachedComments_.Count > 0) {
int dataSize = 0;
foreach (string element in leadingDetachedComments_) {
dataSize += pb::CodedOutputStream.ComputeStringSize(element);
}
size += dataSize;
size += 1 * leadingDetachedComments_.Count;
}
size += leadingDetachedComments_.CalculateSize(_repeated_leadingDetachedComments_codec);
return size;
}
......@@ -4942,12 +4776,12 @@ namespace Google.Protobuf.DescriptorProtos {
break;
case 10:
case 8: {
input.ReadInt32Array(path_);
path_.AddEntriesFrom(input, _repeated_path_codec);
break;
}
case 18:
case 16: {
input.ReadInt32Array(span_);
span_.AddEntriesFrom(input, _repeated_span_codec);
break;
}
case 26: {
......@@ -4959,7 +4793,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 50: {
input.ReadStringArray(leadingDetachedComments_);
leadingDetachedComments_.AddEntriesFrom(input, _repeated_leadingDetachedComments_codec);
break;
}
}
......
csharp/src/ProtocolBuffers/FieldCodec.cs
View file @ f2a27cc2
......@@ -145,28 +145,68 @@ namespace Google.Protobuf
private readonly Func<CodedInputStream, T> reader;
private readonly Action<CodedOutputStream, T> writer;
private readonly Func<T, int> sizeComputer;
private readonly Func<T, int> sizeCalculator;
private readonly uint tag;
private readonly int tagSize;
private readonly int fixedSize;
internal FieldCodec(
Func<CodedInputStream, T> reader,
Action<CodedOutputStream, T> writer,
Func<T, int> sizeComputer,
Func<T, int> sizeCalculator,
uint tag)
{
this.reader = reader;
this.writer = writer;
this.sizeComputer = sizeComputer;
this.sizeCalculator = sizeCalculator;
this.fixedSize = 0;
this.tag = tag;
tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
}
internal FieldCodec(
Func<CodedInputStream, T> reader,
Action<CodedOutputStream, T> writer,
int fixedSize,
uint tag)
{
this.reader = reader;
this.writer = writer;
this.sizeCalculator = _ => fixedSize;
this.fixedSize = fixedSize;
this.tag = tag;
tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
}
/// <summary>
/// Returns the size calculator for just a value.
/// </summary>
internal Func<T, int> ValueSizeCalculator { get { return sizeCalculator; } }
/// <summary>
/// Returns a delegate to write a value (unconditionally) to a coded output stream.
/// </summary>
internal Action<CodedOutputStream, T> ValueWriter { get { return writer; } }
/// <summary>
/// Returns a delegate to read a value from a coded input stream. It is assumed that
/// the stream is already positioned on the appropriate tag.
/// </summary>
internal Func<CodedInputStream, T> ValueReader { get { return reader; } }
/// <summary>
/// Returns the fixed size for an entry, or 0 if sizes vary.
/// </summary>
internal int FixedSize { get { return fixedSize; } }
public uint Tag { get { return tag; } }
public T DefaultValue { get { return Default; } }
public void Write(CodedOutputStream output, T value)
/// <summary>
/// Write a tag and the given value, *if* the value is not the default.
/// </summary>
public void WriteTagAndValue(CodedOutputStream output, T value)
{
if (!IsDefault(value))
{
......@@ -180,9 +220,13 @@ namespace Google.Protobuf
return reader(input);
}
public int CalculateSize(T value)
/// <summary>
/// Calculates the size required to write the given value, with a tag,
/// if the value is not the default.
/// </summary>
public int CalculateSizeWithTag(T value)
{
return IsDefault(value) ? 0 : sizeComputer(value) + CodedOutputStream.ComputeRawVarint32Size(tag);
return IsDefault(value) ? 0 : sizeCalculator(value) + tagSize;
}
}
}
src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
View file @ f2a27cc2
......@@ -49,7 +49,6 @@ namespace csharp {
RepeatedEnumFieldGenerator::RepeatedEnumFieldGenerator(
const FieldDescriptor* descriptor, int fieldOrdinal)
: FieldGeneratorBase(descriptor, fieldOrdinal) {
variables_["packed"] = descriptor->is_packed() ? "Packed" : "";
}
RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {
......@@ -57,6 +56,10 @@ RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {
}
void RepeatedEnumFieldGenerator::GenerateMembers(io::Printer* printer) {
printer->Print(
variables_,
"private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
" = pb::FieldCodec.ForEnum($tag$, x => (int) x, x => ($type_name$) x);");
printer->Print(variables_,
"private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
AddDeprecatedFlag(printer);
......@@ -76,53 +79,19 @@ void RepeatedEnumFieldGenerator::GenerateMergingCode(io::Printer* printer) {
void RepeatedEnumFieldGenerator::GenerateParsingCode(io::Printer* printer) {
printer->Print(
variables_,
"input.ReadEnumArray<$type_name$>($name$_);\n");
"$name$_.AddEntriesFrom(input, _repeated_$name$_codec);\n");
}
void RepeatedEnumFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n");
printer->Indent();
if (descriptor_->is_packed()) {
printer->Print(
variables_,
"output.WriteRawTag($tag_bytes$);\n"
"output.WritePackedEnumArray($name$_);\n");
} else {
printer->Print(
variables_,
"output.Write$capitalized_type_name$Array($number$, $name$_);\n");
}
printer->Outdent();
printer->Print("}\n");
"$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedEnumFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
// TODO(jonskeet): Move all this code into CodedOutputStream? It's a lot to repeat everywhere...
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n");
printer->Indent();
printer->Print("int dataSize = 0;\n");
printer->Print(
variables_,
"foreach ($type_name$ element in $name$_) {\n"
" dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);\n"
"}\n"
"size += dataSize;\n");
int tagSize = internal::WireFormat::TagSize(descriptor_->number(), descriptor_->type());
if (descriptor_->is_packed()) {
printer->Print(
"size += $tag_size$ + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);\n",
"tag_size", SimpleItoa(tagSize));
} else {
printer->Print(
"size += $tag_size$ * $name$_.Count;\n",
"tag_size", SimpleItoa(tagSize), "name", name());
}
printer->Outdent();
printer->Print("}\n");
"size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
}
void RepeatedEnumFieldGenerator::WriteHash(io::Printer* printer) {
......
src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
View file @ f2a27cc2
......@@ -55,6 +55,10 @@ RepeatedMessageFieldGenerator::~RepeatedMessageFieldGenerator() {
}
void RepeatedMessageFieldGenerator::GenerateMembers(io::Printer* printer) {
printer->Print(
variables_,
"private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
" = pb::FieldCodec.ForMessage($tag$, $type_name$.Parser);\n");
printer->Print(
variables_,
"private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
......@@ -75,28 +79,19 @@ void RepeatedMessageFieldGenerator::GenerateMergingCode(io::Printer* printer) {
void RepeatedMessageFieldGenerator::GenerateParsingCode(io::Printer* printer) {
printer->Print(
variables_,
"input.ReadMessageArray($name$_, $type_name$.Parser);\n");
"$name$_.AddEntriesFrom(input, _repeated_$name$_codec);\n");
}
void RepeatedMessageFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
// TODO(jonskeet): Bake the foreach loop into the generated code? We lose the
// advantage of knowing the tag bytes this way :(
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n"
" output.WriteMessageArray($number$, $name$_);\n"
"}\n");
"$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedMessageFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n"
" foreach ($type_name$ element in $name$_) {\n"
" size += pb::CodedOutputStream.ComputeMessageSize(element);\n"
" }\n"
" size += $tag_size$ * $name$_.Count;\n"
"}\n");
"size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
}
void RepeatedMessageFieldGenerator::WriteHash(io::Printer* printer) {
......
src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
View file @ f2a27cc2
......@@ -49,7 +49,6 @@ namespace csharp {
RepeatedPrimitiveFieldGenerator::RepeatedPrimitiveFieldGenerator(
const FieldDescriptor* descriptor, int fieldOrdinal)
: FieldGeneratorBase(descriptor, fieldOrdinal) {
variables_["packed"] = descriptor->is_packed() ? "Packed" : "";
}
RepeatedPrimitiveFieldGenerator::~RepeatedPrimitiveFieldGenerator() {
......@@ -57,6 +56,10 @@ RepeatedPrimitiveFieldGenerator::~RepeatedPrimitiveFieldGenerator() {
}
void RepeatedPrimitiveFieldGenerator::GenerateMembers(io::Printer* printer) {
printer->Print(
variables_,
"private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
" = pb::FieldCodec.For$capitalized_type_name$($tag$);\n");
printer->Print(variables_,
"private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
AddDeprecatedFlag(printer);
......@@ -74,63 +77,21 @@ void RepeatedPrimitiveFieldGenerator::GenerateMergingCode(io::Printer* printer)
}
void RepeatedPrimitiveFieldGenerator::GenerateParsingCode(io::Printer* printer) {
printer->Print(variables_,
"input.Read$capitalized_type_name$Array($name$_);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializationCode(
io::Printer* printer) {
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n");
printer->Indent();
if (descriptor_->is_packed()) {
printer->Print(
variables_,
"output.WriteRawTag($tag_bytes$);\n"
"output.WritePacked$capitalized_type_name$Array($name$_);\n");
} else {
"$name$_.AddEntriesFrom(input, _repeated_$name$_codec);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
printer->Print(
variables_,
"output.Write$capitalized_type_name$Array($number$, $name$_);\n");
}
printer->Outdent();
printer->Print("}\n");
"$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializedSizeCode(
io::Printer* printer) {
// TODO(jonskeet): Do this in the runtime if possible. It's a pain, but it must be feasible...
printer->Print(
"if ($name$_.Count > 0) {\n",
"name", name());
printer->Indent();
printer->Print("int dataSize = 0;\n");
int fixedSize = GetFixedSize(descriptor_->type());
if (fixedSize == -1) {
void RepeatedPrimitiveFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
printer->Print(
variables_,
"foreach ($type_name$ element in $name$_) {\n"
" dataSize += pb::CodedOutputStream.Compute$capitalized_type_name$Size(element);\n"
"}\n");
} else {
printer->Print(
"dataSize = $size$ * $name$_.Count;\n",
"size", SimpleItoa(fixedSize), "name", name());
}
printer->Print("size += dataSize;\n");
int tagSize = internal::WireFormat::TagSize(descriptor_->number(), descriptor_->type());
if (descriptor_->is_packed()) {
printer->Print(
"size += $tag_size$ + pb::CodedOutputStream.ComputeInt32Size(dataSize);\n",
"tag_size", SimpleItoa(tagSize));
} else {
printer->Print(
"size += $tag_size$ * $name$_.Count;\n",
"tag_size", SimpleItoa(tagSize), "name", name());
}
printer->Outdent();
printer->Print("}\n");
"size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
}
void RepeatedPrimitiveFieldGenerator::WriteHash(io::Printer* printer) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment