Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Refactoring the ICoded interfaces (again) removing the use of some generic methods.

Browse Source
pull/288/head
csharptest 14 years ago committed by rogerk
parent ced18e10ae
commit b00ea13eb1
19 changed files with 1197 additions and 930 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/AddressBook/AddressBookProtos.cs
  2. 1
      src/ProtoBench/Program.cs
  3. 4
      src/ProtoGen/RepeatedEnumFieldGenerator.cs
  4. 2
      src/ProtoGen/RepeatedMessageFieldGenerator.cs
  5. 6
      src/ProtoGen/RepeatedPrimitiveFieldGenerator.cs
  6. 2
      src/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs
  7. 30
      src/ProtocolBuffers.Test/TestProtos/UnitTestGoogleSpeedProtoFile.cs
  8. 2
      src/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs
  9. 250
      src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs
  10. 10
      src/ProtocolBuffers.Test/TestProtos/UnitTestRpcInterop.cs
  11. 14
      src/ProtocolBuffers.Test/TestProtos/UnitTestXmlSerializerTestProtoFile.cs
  12. 338
      src/ProtocolBuffers/CodedInputStream.cs
  13. 633
      src/ProtocolBuffers/CodedOutputStream.cs
  14. 44
      src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
  15. 52
      src/ProtocolBuffers/ICodedInputStream.cs
  16. 115
      src/ProtocolBuffers/ICodedOutputStream.cs
  17. 8
      src/ProtocolBuffersLite.Test/TestProtos/UnitTestExtrasLiteProtoFile.cs
  18. 190
      src/ProtocolBuffersLite.Test/TestProtos/UnitTestLiteProtoFile.cs
  19. 250
      src/ProtocolBuffersLite.Test/TestProtos/UnitTestProtoFile.cs

4
src/AddressBook/AddressBookProtos.cs
Unescape View File

@ -461,7 +461,7 @@ namespace Google.ProtocolBuffers.Examples.AddressBook {
output.WriteString(3, field_names[0], Email); output.WriteString(3, field_names[0], Email);
} }
if (phone_.Count > 0) { if (phone_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 4, field_names[3], phone_); output.WriteMessageArray(4, field_names[3], phone_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -812,7 +812,7 @@ namespace Google.ProtocolBuffers.Examples.AddressBook {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _addressBookFieldNames; string[] field_names = _addressBookFieldNames;
if (person_.Count > 0) { if (person_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 1, field_names[0], person_); output.WriteMessageArray(1, field_names[0], person_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }

1
src/ProtoBench/Program.cs
Unescape View File

@ -72,6 +72,7 @@ namespace Google.ProtocolBuffers.ProtoBench
if (temp.Remove("/v2") || temp.Remove("-v2")) if (temp.Remove("/v2") || temp.Remove("-v2"))
{ {
Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime; Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.RealTime;
Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
RunBenchmark = BenchmarkV2; RunBenchmark = BenchmarkV2;
} }
if (temp.Remove("/all") || temp.Remove("-all")) if (temp.Remove("/all") || temp.Remove("-all"))

4
src/ProtoGen/RepeatedEnumFieldGenerator.cs
Unescape View File

@ -132,9 +132,9 @@ namespace Google.ProtocolBuffers.ProtoGen
writer.WriteLine("if ({0}_.Count > 0) {{", Name); writer.WriteLine("if ({0}_.Count > 0) {{", Name);
writer.Indent(); writer.Indent();
if (Descriptor.IsPacked) if (Descriptor.IsPacked)
writer.WriteLine("output.WritePackedArray(pbd::FieldType.{3}, {0}, field_names[{2}], {1}MemoizedSerializedSize, {1}_);", Number, Name, FieldOrdinal, Descriptor.FieldType); writer.WriteLine("output.WritePackedEnumArray({0}, field_names[{2}], {1}MemoizedSerializedSize, {1}_);", Number, Name, FieldOrdinal, Descriptor.FieldType);
else else
writer.WriteLine("output.WriteArray(pbd::FieldType.{3}, {0}, field_names[{2}], {1}_);", Number, Name, FieldOrdinal, Descriptor.FieldType); writer.WriteLine("output.WriteEnumArray({0}, field_names[{2}], {1}_);", Number, Name, FieldOrdinal, Descriptor.FieldType);
writer.Outdent(); writer.Outdent();
writer.WriteLine("}"); writer.WriteLine("}");
} }

2
src/ProtoGen/RepeatedMessageFieldGenerator.cs
Unescape View File

@ -129,7 +129,7 @@ namespace Google.ProtocolBuffers.ProtoGen
{ {
writer.WriteLine("if ({0}_.Count > 0) {{", Name); writer.WriteLine("if ({0}_.Count > 0) {{", Name);
writer.Indent(); writer.Indent();
writer.WriteLine("output.WriteArray(pbd::FieldType.{3}, {0}, field_names[{2}], {1}_);", Number, Name, FieldOrdinal, Descriptor.FieldType); writer.WriteLine("output.Write{0}Array({1}, field_names[{3}], {2}_);", MessageOrGroup, Number, Name, FieldOrdinal, Descriptor.FieldType);
writer.Outdent(); writer.Outdent();
writer.WriteLine("}"); writer.WriteLine("}");
} }

6
src/ProtoGen/RepeatedPrimitiveFieldGenerator.cs
Unescape View File

@ -121,7 +121,7 @@ namespace Google.ProtocolBuffers.ProtoGen
public void GenerateParsingCode(TextGenerator writer) public void GenerateParsingCode(TextGenerator writer)
{ {
writer.WriteLine("input.ReadPrimitiveArray(pbd::FieldType.{1}, tag, field_name, result.{0}_);", Name, Descriptor.FieldType); writer.WriteLine("input.Read{0}Array(tag, field_name, result.{1}_);", CapitalizedTypeName, Name, Descriptor.FieldType);
} }
public void GenerateSerializationCode(TextGenerator writer) public void GenerateSerializationCode(TextGenerator writer)
@ -129,9 +129,9 @@ namespace Google.ProtocolBuffers.ProtoGen
writer.WriteLine("if ({0}_.Count > 0) {{", Name); writer.WriteLine("if ({0}_.Count > 0) {{", Name);
writer.Indent(); writer.Indent();
if (Descriptor.IsPacked) if (Descriptor.IsPacked)
writer.WriteLine("output.WritePackedArray(pbd::FieldType.{3}, {0}, field_names[{2}], {1}MemoizedSerializedSize, {1}_);", Number, Name, FieldOrdinal, Descriptor.FieldType); writer.WriteLine("output.WritePacked{0}Array({1}, field_names[{3}], {2}MemoizedSerializedSize, {2}_);", CapitalizedTypeName, Number, Name, FieldOrdinal, Descriptor.FieldType);
else else
writer.WriteLine("output.WriteArray(pbd::FieldType.{3}, {0}, field_names[{2}], {1}_);", Number, Name, FieldOrdinal, Descriptor.FieldType); writer.WriteLine("output.Write{0}Array({1}, field_names[{3}], {2}_);", CapitalizedTypeName, Number, Name, FieldOrdinal, Descriptor.FieldType);
writer.Outdent(); writer.Outdent();
writer.WriteLine("}"); writer.WriteLine("}");
} }

2
src/ProtocolBuffers.Test/TestProtos/UnitTestEmbedOptimizeForProtoFile.cs
Unescape View File

@ -126,7 +126,7 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteMessage(1, field_names[0], OptionalMessage); output.WriteMessage(1, field_names[0], OptionalMessage);
} }
if (repeatedMessage_.Count > 0) { if (repeatedMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 2, field_names[1], repeatedMessage_); output.WriteMessageArray(2, field_names[1], repeatedMessage_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }

30
src/ProtocolBuffers.Test/TestProtos/UnitTestGoogleSpeedProtoFile.cs
Unescape View File

@ -597,7 +597,7 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteString(4, field_names[29], Field4); output.WriteString(4, field_names[29], Field4);
} }
if (field5_.Count > 0) { if (field5_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed64, 5, field_names[30], field5_); output.WriteFixed64Array(5, field_names[30], field5_);
} }
if (hasField6) { if (hasField6) {
output.WriteInt32(6, field_names[32], Field6); output.WriteInt32(6, field_names[32], Field6);
@ -1122,7 +1122,7 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 42: case 42:
case 41: { case 41: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.field5_); input.ReadFixed64Array(tag, field_name, result.field5_);
break; break;
} }
case 48: { case 48: {
@ -3348,7 +3348,7 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteString(13, field_names[2], Field13); output.WriteString(13, field_names[2], Field13);
} }
if (field14_.Count > 0) { if (field14_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 14, field_names[3], field14_); output.WriteStringArray(14, field_names[3], field14_);
} }
if (hasField15) { if (hasField15) {
output.WriteUInt64(15, field_names[4], Field15); output.WriteUInt64(15, field_names[4], Field15);
@ -3360,7 +3360,7 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteInt32(20, field_names[6], Field20); output.WriteInt32(20, field_names[6], Field20);
} }
if (field22_.Count > 0) { if (field22_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 22, field_names[7], field22_); output.WriteStringArray(22, field_names[7], field22_);
} }
if (hasField24) { if (hasField24) {
output.WriteString(24, field_names[8], Field24); output.WriteString(24, field_names[8], Field24);
@ -3381,7 +3381,7 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteMessage(31, field_names[13], Field31); output.WriteMessage(31, field_names[13], Field31);
} }
if (field73_.Count > 0) { if (field73_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 73, field_names[15], field73_); output.WriteInt32Array(73, field_names[15], field73_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -3661,7 +3661,7 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 114: { case 114: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.field14_); input.ReadStringArray(tag, field_name, result.field14_);
break; break;
} }
case 120: { case 120: {
@ -3677,7 +3677,7 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 178: { case 178: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.field22_); input.ReadStringArray(tag, field_name, result.field22_);
break; break;
} }
case 194: { case 194: {
@ -3711,7 +3711,7 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 586: case 586:
case 584: { case 584: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.field73_); input.ReadInt32Array(tag, field_name, result.field73_);
break; break;
} }
} }
@ -4407,7 +4407,7 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteString(6, field_names[25], Field6); output.WriteString(6, field_names[25], Field6);
} }
if (group1_.Count > 0) { if (group1_.Count > 0) {
output.WriteArray(pbd::FieldType.Group, 10, field_names[29], group1_); output.WriteGroupArray(10, field_names[29], group1_);
} }
if (hasField21) { if (hasField21) {
output.WriteInt32(21, field_names[10], Field21); output.WriteInt32(21, field_names[10], Field21);
@ -4431,16 +4431,16 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteInt32(109, field_names[1], Field109); output.WriteInt32(109, field_names[1], Field109);
} }
if (field127_.Count > 0) { if (field127_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 127, field_names[2], field127_); output.WriteStringArray(127, field_names[2], field127_);
} }
if (field128_.Count > 0) { if (field128_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 128, field_names[3], field128_); output.WriteStringArray(128, field_names[3], field128_);
} }
if (hasField129) { if (hasField129) {
output.WriteInt32(129, field_names[4], Field129); output.WriteInt32(129, field_names[4], Field129);
} }
if (field130_.Count > 0) { if (field130_.Count > 0) {
output.WriteArray(pbd::FieldType.Int64, 130, field_names[5], field130_); output.WriteInt64Array(130, field_names[5], field130_);
} }
if (hasField131) { if (hasField131) {
output.WriteInt64(131, field_names[6], Field131); output.WriteInt64(131, field_names[6], Field131);
@ -4880,11 +4880,11 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 1018: { case 1018: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.field127_); input.ReadStringArray(tag, field_name, result.field127_);
break; break;
} }
case 1026: { case 1026: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.field128_); input.ReadStringArray(tag, field_name, result.field128_);
break; break;
} }
case 1032: { case 1032: {
@ -4893,7 +4893,7 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 1042: case 1042:
case 1040: { case 1040: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.field130_); input.ReadInt64Array(tag, field_name, result.field130_);
break; break;
} }
case 1048: { case 1048: {

2
src/ProtocolBuffers.Test/TestProtos/UnitTestMessageSetProtoFile.cs
Unescape View File

@ -1385,7 +1385,7 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _rawMessageSetFieldNames; string[] field_names = _rawMessageSetFieldNames;
if (item_.Count > 0) { if (item_.Count > 0) {
output.WriteArray(pbd::FieldType.Group, 1, field_names[0], item_); output.WriteGroupArray(1, field_names[0], item_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }

250
src/ProtocolBuffers.Test/TestProtos/UnitTestProtoFile.cs
Unescape View File

@ -2702,76 +2702,76 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteString(25, field_names[22], OptionalCord); output.WriteString(25, field_names[22], OptionalCord);
} }
if (repeatedInt32_.Count > 0) { if (repeatedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 31, field_names[55], repeatedInt32_); output.WriteInt32Array(31, field_names[55], repeatedInt32_);
} }
if (repeatedInt64_.Count > 0) { if (repeatedInt64_.Count > 0) {
output.WriteArray(pbd::FieldType.Int64, 32, field_names[56], repeatedInt64_); output.WriteInt64Array(32, field_names[56], repeatedInt64_);
} }
if (repeatedUint32_.Count > 0) { if (repeatedUint32_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt32, 33, field_names[65], repeatedUint32_); output.WriteUInt32Array(33, field_names[65], repeatedUint32_);
} }
if (repeatedUint64_.Count > 0) { if (repeatedUint64_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt64, 34, field_names[66], repeatedUint64_); output.WriteUInt64Array(34, field_names[66], repeatedUint64_);
} }
if (repeatedSint32_.Count > 0) { if (repeatedSint32_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt32, 35, field_names[61], repeatedSint32_); output.WriteSInt32Array(35, field_names[61], repeatedSint32_);
} }
if (repeatedSint64_.Count > 0) { if (repeatedSint64_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt64, 36, field_names[62], repeatedSint64_); output.WriteSInt64Array(36, field_names[62], repeatedSint64_);
} }
if (repeatedFixed32_.Count > 0) { if (repeatedFixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed32, 37, field_names[48], repeatedFixed32_); output.WriteFixed32Array(37, field_names[48], repeatedFixed32_);
} }
if (repeatedFixed64_.Count > 0) { if (repeatedFixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed64, 38, field_names[49], repeatedFixed64_); output.WriteFixed64Array(38, field_names[49], repeatedFixed64_);
} }
if (repeatedSfixed32_.Count > 0) { if (repeatedSfixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed32, 39, field_names[59], repeatedSfixed32_); output.WriteSFixed32Array(39, field_names[59], repeatedSfixed32_);
} }
if (repeatedSfixed64_.Count > 0) { if (repeatedSfixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed64, 40, field_names[60], repeatedSfixed64_); output.WriteSFixed64Array(40, field_names[60], repeatedSfixed64_);
} }
if (repeatedFloat_.Count > 0) { if (repeatedFloat_.Count > 0) {
output.WriteArray(pbd::FieldType.Float, 41, field_names[50], repeatedFloat_); output.WriteFloatArray(41, field_names[50], repeatedFloat_);
} }
if (repeatedDouble_.Count > 0) { if (repeatedDouble_.Count > 0) {
output.WriteArray(pbd::FieldType.Double, 42, field_names[47], repeatedDouble_); output.WriteDoubleArray(42, field_names[47], repeatedDouble_);
} }
if (repeatedBool_.Count > 0) { if (repeatedBool_.Count > 0) {
output.WriteArray(pbd::FieldType.Bool, 43, field_names[44], repeatedBool_); output.WriteBoolArray(43, field_names[44], repeatedBool_);
} }
if (repeatedString_.Count > 0) { if (repeatedString_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 44, field_names[63], repeatedString_); output.WriteStringArray(44, field_names[63], repeatedString_);
} }
if (repeatedBytes_.Count > 0) { if (repeatedBytes_.Count > 0) {
output.WriteArray(pbd::FieldType.Bytes, 45, field_names[45], repeatedBytes_); output.WriteBytesArray(45, field_names[45], repeatedBytes_);
} }
if (repeatedGroup_.Count > 0) { if (repeatedGroup_.Count > 0) {
output.WriteArray(pbd::FieldType.Group, 46, field_names[67], repeatedGroup_); output.WriteGroupArray(46, field_names[67], repeatedGroup_);
} }
if (repeatedNestedMessage_.Count > 0) { if (repeatedNestedMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 48, field_names[58], repeatedNestedMessage_); output.WriteMessageArray(48, field_names[58], repeatedNestedMessage_);
} }
if (repeatedForeignMessage_.Count > 0) { if (repeatedForeignMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 49, field_names[52], repeatedForeignMessage_); output.WriteMessageArray(49, field_names[52], repeatedForeignMessage_);
} }
if (repeatedImportMessage_.Count > 0) { if (repeatedImportMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 50, field_names[54], repeatedImportMessage_); output.WriteMessageArray(50, field_names[54], repeatedImportMessage_);
} }
if (repeatedNestedEnum_.Count > 0) { if (repeatedNestedEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 51, field_names[57], repeatedNestedEnum_); output.WriteEnumArray(51, field_names[57], repeatedNestedEnum_);
} }
if (repeatedForeignEnum_.Count > 0) { if (repeatedForeignEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 52, field_names[51], repeatedForeignEnum_); output.WriteEnumArray(52, field_names[51], repeatedForeignEnum_);
} }
if (repeatedImportEnum_.Count > 0) { if (repeatedImportEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 53, field_names[53], repeatedImportEnum_); output.WriteEnumArray(53, field_names[53], repeatedImportEnum_);
} }
if (repeatedStringPiece_.Count > 0) { if (repeatedStringPiece_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 54, field_names[64], repeatedStringPiece_); output.WriteStringArray(54, field_names[64], repeatedStringPiece_);
} }
if (repeatedCord_.Count > 0) { if (repeatedCord_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 55, field_names[46], repeatedCord_); output.WriteStringArray(55, field_names[46], repeatedCord_);
} }
if (hasDefaultInt32) { if (hasDefaultInt32) {
output.WriteInt32(61, field_names[9], DefaultInt32); output.WriteInt32(61, field_names[9], DefaultInt32);
@ -3646,75 +3646,75 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 250: case 250:
case 248: { case 248: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.repeatedInt32_); input.ReadInt32Array(tag, field_name, result.repeatedInt32_);
break; break;
} }
case 258: case 258:
case 256: { case 256: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.repeatedInt64_); input.ReadInt64Array(tag, field_name, result.repeatedInt64_);
break; break;
} }
case 266: case 266:
case 264: { case 264: {
input.ReadPrimitiveArray(pbd::FieldType.UInt32, tag, field_name, result.repeatedUint32_); input.ReadUInt32Array(tag, field_name, result.repeatedUint32_);
break; break;
} }
case 274: case 274:
case 272: { case 272: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.repeatedUint64_); input.ReadUInt64Array(tag, field_name, result.repeatedUint64_);
break; break;
} }
case 282: case 282:
case 280: { case 280: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.repeatedSint32_); input.ReadSInt32Array(tag, field_name, result.repeatedSint32_);
break; break;
} }
case 290: case 290:
case 288: { case 288: {
input.ReadPrimitiveArray(pbd::FieldType.SInt64, tag, field_name, result.repeatedSint64_); input.ReadSInt64Array(tag, field_name, result.repeatedSint64_);
break; break;
} }
case 298: case 298:
case 301: { case 301: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.repeatedFixed32_); input.ReadFixed32Array(tag, field_name, result.repeatedFixed32_);
break; break;
} }
case 306: case 306:
case 305: { case 305: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.repeatedFixed64_); input.ReadFixed64Array(tag, field_name, result.repeatedFixed64_);
break; break;
} }
case 314: case 314:
case 317: { case 317: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed32, tag, field_name, result.repeatedSfixed32_); input.ReadSFixed32Array(tag, field_name, result.repeatedSfixed32_);
break; break;
} }
case 322: case 322:
case 321: { case 321: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed64, tag, field_name, result.repeatedSfixed64_); input.ReadSFixed64Array(tag, field_name, result.repeatedSfixed64_);
break; break;
} }
case 330: case 330:
case 333: { case 333: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.repeatedFloat_); input.ReadFloatArray(tag, field_name, result.repeatedFloat_);
break; break;
} }
case 338: case 338:
case 337: { case 337: {
input.ReadPrimitiveArray(pbd::FieldType.Double, tag, field_name, result.repeatedDouble_); input.ReadDoubleArray(tag, field_name, result.repeatedDouble_);
break; break;
} }
case 346: case 346:
case 344: { case 344: {
input.ReadPrimitiveArray(pbd::FieldType.Bool, tag, field_name, result.repeatedBool_); input.ReadBoolArray(tag, field_name, result.repeatedBool_);
break; break;
} }
case 354: { case 354: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedString_); input.ReadStringArray(tag, field_name, result.repeatedString_);
break; break;
} }
case 362: { case 362: {
input.ReadPrimitiveArray(pbd::FieldType.Bytes, tag, field_name, result.repeatedBytes_); input.ReadBytesArray(tag, field_name, result.repeatedBytes_);
break; break;
} }
case 371: { case 371: {
@ -3776,11 +3776,11 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 434: { case 434: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedStringPiece_); input.ReadStringArray(tag, field_name, result.repeatedStringPiece_);
break; break;
} }
case 442: { case 442: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedCord_); input.ReadStringArray(tag, field_name, result.repeatedCord_);
break; break;
} }
case 488: { case 488: {
@ -8485,7 +8485,7 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteMessage(1, field_names[1], OptionalMessage); output.WriteMessage(1, field_names[1], OptionalMessage);
} }
if (repeatedMessage_.Count > 0) { if (repeatedMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 2, field_names[2], repeatedMessage_); output.WriteMessageArray(2, field_names[2], repeatedMessage_);
} }
if (hasDummy) { if (hasDummy) {
output.WriteInt32(3, field_names[0], Dummy); output.WriteInt32(3, field_names[0], Dummy);
@ -11742,10 +11742,10 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _nestedMessageFieldNames; string[] field_names = _nestedMessageFieldNames;
if (nestedmessageRepeatedInt32_.Count > 0) { if (nestedmessageRepeatedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 1, field_names[1], nestedmessageRepeatedInt32_); output.WriteInt32Array(1, field_names[1], nestedmessageRepeatedInt32_);
} }
if (nestedmessageRepeatedForeignmessage_.Count > 0) { if (nestedmessageRepeatedForeignmessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 2, field_names[0], nestedmessageRepeatedForeignmessage_); output.WriteMessageArray(2, field_names[0], nestedmessageRepeatedForeignmessage_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -11915,7 +11915,7 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 10: case 10:
case 8: { case 8: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.nestedmessageRepeatedInt32_); input.ReadInt32Array(tag, field_name, result.nestedmessageRepeatedInt32_);
break; break;
} }
case 18: { case 18: {
@ -12426,22 +12426,22 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteString(6, field_names[0], CordField); output.WriteString(6, field_names[0], CordField);
} }
if (repeatedPrimitiveField_.Count > 0) { if (repeatedPrimitiveField_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 7, field_names[7], repeatedPrimitiveField_); output.WriteInt32Array(7, field_names[7], repeatedPrimitiveField_);
} }
if (repeatedStringField_.Count > 0) { if (repeatedStringField_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 8, field_names[8], repeatedStringField_); output.WriteStringArray(8, field_names[8], repeatedStringField_);
} }
if (repeatedEnumField_.Count > 0) { if (repeatedEnumField_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 9, field_names[5], repeatedEnumField_); output.WriteEnumArray(9, field_names[5], repeatedEnumField_);
} }
if (repeatedMessageField_.Count > 0) { if (repeatedMessageField_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 10, field_names[6], repeatedMessageField_); output.WriteMessageArray(10, field_names[6], repeatedMessageField_);
} }
if (repeatedStringPieceField_.Count > 0) { if (repeatedStringPieceField_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 11, field_names[9], repeatedStringPieceField_); output.WriteStringArray(11, field_names[9], repeatedStringPieceField_);
} }
if (repeatedCordField_.Count > 0) { if (repeatedCordField_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 12, field_names[4], repeatedCordField_); output.WriteStringArray(12, field_names[4], repeatedCordField_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -12734,11 +12734,11 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 58: case 58:
case 56: { case 56: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.repeatedPrimitiveField_); input.ReadInt32Array(tag, field_name, result.repeatedPrimitiveField_);
break; break;
} }
case 66: { case 66: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedStringField_); input.ReadStringArray(tag, field_name, result.repeatedStringField_);
break; break;
} }
case 74: case 74:
@ -12760,11 +12760,11 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 90: { case 90: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedStringPieceField_); input.ReadStringArray(tag, field_name, result.repeatedStringPieceField_);
break; break;
} }
case 98: { case 98: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedCordField_); input.ReadStringArray(tag, field_name, result.repeatedCordField_);
break; break;
} }
} }
@ -15105,46 +15105,46 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _testPackedTypesFieldNames; string[] field_names = _testPackedTypesFieldNames;
if (packedInt32_.Count > 0) { if (packedInt32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Int32, 90, field_names[6], packedInt32MemoizedSerializedSize, packedInt32_); output.WritePackedInt32Array(90, field_names[6], packedInt32MemoizedSerializedSize, packedInt32_);
} }
if (packedInt64_.Count > 0) { if (packedInt64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Int64, 91, field_names[7], packedInt64MemoizedSerializedSize, packedInt64_); output.WritePackedInt64Array(91, field_names[7], packedInt64MemoizedSerializedSize, packedInt64_);
} }
if (packedUint32_.Count > 0) { if (packedUint32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.UInt32, 92, field_names[12], packedUint32MemoizedSerializedSize, packedUint32_); output.WritePackedUInt32Array(92, field_names[12], packedUint32MemoizedSerializedSize, packedUint32_);
} }
if (packedUint64_.Count > 0) { if (packedUint64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.UInt64, 93, field_names[13], packedUint64MemoizedSerializedSize, packedUint64_); output.WritePackedUInt64Array(93, field_names[13], packedUint64MemoizedSerializedSize, packedUint64_);
} }
if (packedSint32_.Count > 0) { if (packedSint32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SInt32, 94, field_names[10], packedSint32MemoizedSerializedSize, packedSint32_); output.WritePackedSInt32Array(94, field_names[10], packedSint32MemoizedSerializedSize, packedSint32_);
} }
if (packedSint64_.Count > 0) { if (packedSint64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SInt64, 95, field_names[11], packedSint64MemoizedSerializedSize, packedSint64_); output.WritePackedSInt64Array(95, field_names[11], packedSint64MemoizedSerializedSize, packedSint64_);
} }
if (packedFixed32_.Count > 0) { if (packedFixed32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Fixed32, 96, field_names[3], packedFixed32MemoizedSerializedSize, packedFixed32_); output.WritePackedFixed32Array(96, field_names[3], packedFixed32MemoizedSerializedSize, packedFixed32_);
} }
if (packedFixed64_.Count > 0) { if (packedFixed64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Fixed64, 97, field_names[4], packedFixed64MemoizedSerializedSize, packedFixed64_); output.WritePackedFixed64Array(97, field_names[4], packedFixed64MemoizedSerializedSize, packedFixed64_);
} }
if (packedSfixed32_.Count > 0) { if (packedSfixed32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SFixed32, 98, field_names[8], packedSfixed32MemoizedSerializedSize, packedSfixed32_); output.WritePackedSFixed32Array(98, field_names[8], packedSfixed32MemoizedSerializedSize, packedSfixed32_);
} }
if (packedSfixed64_.Count > 0) { if (packedSfixed64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SFixed64, 99, field_names[9], packedSfixed64MemoizedSerializedSize, packedSfixed64_); output.WritePackedSFixed64Array(99, field_names[9], packedSfixed64MemoizedSerializedSize, packedSfixed64_);
} }
if (packedFloat_.Count > 0) { if (packedFloat_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Float, 100, field_names[5], packedFloatMemoizedSerializedSize, packedFloat_); output.WritePackedFloatArray(100, field_names[5], packedFloatMemoizedSerializedSize, packedFloat_);
} }
if (packedDouble_.Count > 0) { if (packedDouble_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Double, 101, field_names[1], packedDoubleMemoizedSerializedSize, packedDouble_); output.WritePackedDoubleArray(101, field_names[1], packedDoubleMemoizedSerializedSize, packedDouble_);
} }
if (packedBool_.Count > 0) { if (packedBool_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Bool, 102, field_names[0], packedBoolMemoizedSerializedSize, packedBool_); output.WritePackedBoolArray(102, field_names[0], packedBoolMemoizedSerializedSize, packedBool_);
} }
if (packedEnum_.Count > 0) { if (packedEnum_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Enum, 103, field_names[2], packedEnumMemoizedSerializedSize, packedEnum_); output.WritePackedEnumArray(103, field_names[2], packedEnumMemoizedSerializedSize, packedEnum_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -15492,67 +15492,67 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 722: case 722:
case 720: { case 720: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.packedInt32_); input.ReadInt32Array(tag, field_name, result.packedInt32_);
break; break;
} }
case 730: case 730:
case 728: { case 728: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.packedInt64_); input.ReadInt64Array(tag, field_name, result.packedInt64_);
break; break;
} }
case 738: case 738:
case 736: { case 736: {
input.ReadPrimitiveArray(pbd::FieldType.UInt32, tag, field_name, result.packedUint32_); input.ReadUInt32Array(tag, field_name, result.packedUint32_);
break; break;
} }
case 746: case 746:
case 744: { case 744: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.packedUint64_); input.ReadUInt64Array(tag, field_name, result.packedUint64_);
break; break;
} }
case 754: case 754:
case 752: { case 752: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.packedSint32_); input.ReadSInt32Array(tag, field_name, result.packedSint32_);
break; break;
} }
case 762: case 762:
case 760: { case 760: {
input.ReadPrimitiveArray(pbd::FieldType.SInt64, tag, field_name, result.packedSint64_); input.ReadSInt64Array(tag, field_name, result.packedSint64_);
break; break;
} }
case 770: case 770:
case 773: { case 773: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.packedFixed32_); input.ReadFixed32Array(tag, field_name, result.packedFixed32_);
break; break;
} }
case 778: case 778:
case 777: { case 777: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.packedFixed64_); input.ReadFixed64Array(tag, field_name, result.packedFixed64_);
break; break;
} }
case 786: case 786:
case 789: { case 789: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed32, tag, field_name, result.packedSfixed32_); input.ReadSFixed32Array(tag, field_name, result.packedSfixed32_);
break; break;
} }
case 794: case 794:
case 793: { case 793: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed64, tag, field_name, result.packedSfixed64_); input.ReadSFixed64Array(tag, field_name, result.packedSfixed64_);
break; break;
} }
case 802: case 802:
case 805: { case 805: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.packedFloat_); input.ReadFloatArray(tag, field_name, result.packedFloat_);
break; break;
} }
case 810: case 810:
case 809: { case 809: {
input.ReadPrimitiveArray(pbd::FieldType.Double, tag, field_name, result.packedDouble_); input.ReadDoubleArray(tag, field_name, result.packedDouble_);
break; break;
} }
case 818: case 818:
case 816: { case 816: {
input.ReadPrimitiveArray(pbd::FieldType.Bool, tag, field_name, result.packedBool_); input.ReadBoolArray(tag, field_name, result.packedBool_);
break; break;
} }
case 826: case 826:
@ -16181,46 +16181,46 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _testUnpackedTypesFieldNames; string[] field_names = _testUnpackedTypesFieldNames;
if (unpackedInt32_.Count > 0) { if (unpackedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 90, field_names[6], unpackedInt32_); output.WriteInt32Array(90, field_names[6], unpackedInt32_);
} }
if (unpackedInt64_.Count > 0) { if (unpackedInt64_.Count > 0) {
output.WriteArray(pbd::FieldType.Int64, 91, field_names[7], unpackedInt64_); output.WriteInt64Array(91, field_names[7], unpackedInt64_);
} }
if (unpackedUint32_.Count > 0) { if (unpackedUint32_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt32, 92, field_names[12], unpackedUint32_); output.WriteUInt32Array(92, field_names[12], unpackedUint32_);
} }
if (unpackedUint64_.Count > 0) { if (unpackedUint64_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt64, 93, field_names[13], unpackedUint64_); output.WriteUInt64Array(93, field_names[13], unpackedUint64_);
} }
if (unpackedSint32_.Count > 0) { if (unpackedSint32_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt32, 94, field_names[10], unpackedSint32_); output.WriteSInt32Array(94, field_names[10], unpackedSint32_);
} }
if (unpackedSint64_.Count > 0) { if (unpackedSint64_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt64, 95, field_names[11], unpackedSint64_); output.WriteSInt64Array(95, field_names[11], unpackedSint64_);
} }
if (unpackedFixed32_.Count > 0) { if (unpackedFixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed32, 96, field_names[3], unpackedFixed32_); output.WriteFixed32Array(96, field_names[3], unpackedFixed32_);
} }
if (unpackedFixed64_.Count > 0) { if (unpackedFixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed64, 97, field_names[4], unpackedFixed64_); output.WriteFixed64Array(97, field_names[4], unpackedFixed64_);
} }
if (unpackedSfixed32_.Count > 0) { if (unpackedSfixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed32, 98, field_names[8], unpackedSfixed32_); output.WriteSFixed32Array(98, field_names[8], unpackedSfixed32_);
} }
if (unpackedSfixed64_.Count > 0) { if (unpackedSfixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed64, 99, field_names[9], unpackedSfixed64_); output.WriteSFixed64Array(99, field_names[9], unpackedSfixed64_);
} }
if (unpackedFloat_.Count > 0) { if (unpackedFloat_.Count > 0) {
output.WriteArray(pbd::FieldType.Float, 100, field_names[5], unpackedFloat_); output.WriteFloatArray(100, field_names[5], unpackedFloat_);
} }
if (unpackedDouble_.Count > 0) { if (unpackedDouble_.Count > 0) {
output.WriteArray(pbd::FieldType.Double, 101, field_names[1], unpackedDouble_); output.WriteDoubleArray(101, field_names[1], unpackedDouble_);
} }
if (unpackedBool_.Count > 0) { if (unpackedBool_.Count > 0) {
output.WriteArray(pbd::FieldType.Bool, 102, field_names[0], unpackedBool_); output.WriteBoolArray(102, field_names[0], unpackedBool_);
} }
if (unpackedEnum_.Count > 0) { if (unpackedEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 103, field_names[2], unpackedEnum_); output.WriteEnumArray(103, field_names[2], unpackedEnum_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -16527,67 +16527,67 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 722: case 722:
case 720: { case 720: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.unpackedInt32_); input.ReadInt32Array(tag, field_name, result.unpackedInt32_);
break; break;
} }
case 730: case 730:
case 728: { case 728: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.unpackedInt64_); input.ReadInt64Array(tag, field_name, result.unpackedInt64_);
break; break;
} }
case 738: case 738:
case 736: { case 736: {
input.ReadPrimitiveArray(pbd::FieldType.UInt32, tag, field_name, result.unpackedUint32_); input.ReadUInt32Array(tag, field_name, result.unpackedUint32_);
break; break;
} }
case 746: case 746:
case 744: { case 744: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.unpackedUint64_); input.ReadUInt64Array(tag, field_name, result.unpackedUint64_);
break; break;
} }
case 754: case 754:
case 752: { case 752: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.unpackedSint32_); input.ReadSInt32Array(tag, field_name, result.unpackedSint32_);
break; break;
} }
case 762: case 762:
case 760: { case 760: {
input.ReadPrimitiveArray(pbd::FieldType.SInt64, tag, field_name, result.unpackedSint64_); input.ReadSInt64Array(tag, field_name, result.unpackedSint64_);
break; break;
} }
case 770: case 770:
case 773: { case 773: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.unpackedFixed32_); input.ReadFixed32Array(tag, field_name, result.unpackedFixed32_);
break; break;
} }
case 778: case 778:
case 777: { case 777: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.unpackedFixed64_); input.ReadFixed64Array(tag, field_name, result.unpackedFixed64_);
break; break;
} }
case 786: case 786:
case 789: { case 789: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed32, tag, field_name, result.unpackedSfixed32_); input.ReadSFixed32Array(tag, field_name, result.unpackedSfixed32_);
break; break;
} }
case 794: case 794:
case 793: { case 793: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed64, tag, field_name, result.unpackedSfixed64_); input.ReadSFixed64Array(tag, field_name, result.unpackedSfixed64_);
break; break;
} }
case 802: case 802:
case 805: { case 805: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.unpackedFloat_); input.ReadFloatArray(tag, field_name, result.unpackedFloat_);
break; break;
} }
case 810: case 810:
case 809: { case 809: {
input.ReadPrimitiveArray(pbd::FieldType.Double, tag, field_name, result.unpackedDouble_); input.ReadDoubleArray(tag, field_name, result.unpackedDouble_);
break; break;
} }
case 818: case 818:
case 816: { case 816: {
input.ReadPrimitiveArray(pbd::FieldType.Bool, tag, field_name, result.unpackedBool_); input.ReadBoolArray(tag, field_name, result.unpackedBool_);
break; break;
} }
case 826: case 826:
@ -17792,10 +17792,10 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteMessage(2004, field_names[1], DynamicMessageExtension); output.WriteMessage(2004, field_names[1], DynamicMessageExtension);
} }
if (repeatedExtension_.Count > 0) { if (repeatedExtension_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 2005, field_names[5], repeatedExtension_); output.WriteStringArray(2005, field_names[5], repeatedExtension_);
} }
if (packedExtension_.Count > 0) { if (packedExtension_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SInt32, 2006, field_names[4], packedExtensionMemoizedSerializedSize, packedExtension_); output.WritePackedSInt32Array(2006, field_names[4], packedExtensionMemoizedSerializedSize, packedExtension_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -18048,12 +18048,12 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 16042: { case 16042: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedExtension_); input.ReadStringArray(tag, field_name, result.repeatedExtension_);
break; break;
} }
case 16050: case 16050:
case 16048: { case 16048: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.packedExtension_); input.ReadSInt32Array(tag, field_name, result.packedExtension_);
break; break;
} }
} }
@ -18368,22 +18368,22 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _testRepeatedScalarDifferentTagSizesFieldNames; string[] field_names = _testRepeatedScalarDifferentTagSizesFieldNames;
if (repeatedFixed32_.Count > 0) { if (repeatedFixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed32, 12, field_names[0], repeatedFixed32_); output.WriteFixed32Array(12, field_names[0], repeatedFixed32_);
} }
if (repeatedInt32_.Count > 0) { if (repeatedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 13, field_names[3], repeatedInt32_); output.WriteInt32Array(13, field_names[3], repeatedInt32_);
} }
if (repeatedFixed64_.Count > 0) { if (repeatedFixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed64, 2046, field_names[1], repeatedFixed64_); output.WriteFixed64Array(2046, field_names[1], repeatedFixed64_);
} }
if (repeatedInt64_.Count > 0) { if (repeatedInt64_.Count > 0) {
output.WriteArray(pbd::FieldType.Int64, 2047, field_names[4], repeatedInt64_); output.WriteInt64Array(2047, field_names[4], repeatedInt64_);
} }
if (repeatedFloat_.Count > 0) { if (repeatedFloat_.Count > 0) {
output.WriteArray(pbd::FieldType.Float, 262142, field_names[2], repeatedFloat_); output.WriteFloatArray(262142, field_names[2], repeatedFloat_);
} }
if (repeatedUint64_.Count > 0) { if (repeatedUint64_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt64, 262143, field_names[5], repeatedUint64_); output.WriteUInt64Array(262143, field_names[5], repeatedUint64_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -18600,32 +18600,32 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 98: case 98:
case 101: { case 101: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.repeatedFixed32_); input.ReadFixed32Array(tag, field_name, result.repeatedFixed32_);
break; break;
} }
case 106: case 106:
case 104: { case 104: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.repeatedInt32_); input.ReadInt32Array(tag, field_name, result.repeatedInt32_);
break; break;
} }
case 16370: case 16370:
case 16369: { case 16369: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.repeatedFixed64_); input.ReadFixed64Array(tag, field_name, result.repeatedFixed64_);
break; break;
} }
case 16378: case 16378:
case 16376: { case 16376: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.repeatedInt64_); input.ReadInt64Array(tag, field_name, result.repeatedInt64_);
break; break;
} }
case 2097138: case 2097138:
case 2097141: { case 2097141: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.repeatedFloat_); input.ReadFloatArray(tag, field_name, result.repeatedFloat_);
break; break;
} }
case 2097146: case 2097146:
case 2097144: { case 2097144: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.repeatedUint64_); input.ReadUInt64Array(tag, field_name, result.repeatedUint64_);
break; break;
} }
} }

10
src/ProtocolBuffers.Test/TestProtos/UnitTestRpcInterop.cs
Unescape View File

@ -126,7 +126,7 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _searchRequestFieldNames; string[] field_names = _searchRequestFieldNames;
if (criteria_.Count > 0) { if (criteria_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 1, field_names[0], criteria_); output.WriteStringArray(1, field_names[0], criteria_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -288,7 +288,7 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 10: { case 10: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.criteria_); input.ReadStringArray(tag, field_name, result.criteria_);
break; break;
} }
} }
@ -677,7 +677,7 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _searchResponseFieldNames; string[] field_names = _searchResponseFieldNames;
if (results_.Count > 0) { if (results_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 1, field_names[0], results_); output.WriteMessageArray(1, field_names[0], results_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -951,7 +951,7 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _refineSearchRequestFieldNames; string[] field_names = _refineSearchRequestFieldNames;
if (criteria_.Count > 0) { if (criteria_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 1, field_names[0], criteria_); output.WriteStringArray(1, field_names[0], criteria_);
} }
if (hasPreviousResults) { if (hasPreviousResults) {
output.WriteMessage(2, field_names[1], PreviousResults); output.WriteMessage(2, field_names[1], PreviousResults);
@ -1122,7 +1122,7 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 10: { case 10: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.criteria_); input.ReadStringArray(tag, field_name, result.criteria_);
break; break;
} }
case 18: { case 18: {

14
src/ProtocolBuffers.Test/TestProtos/UnitTestXmlSerializerTestProtoFile.cs
Unescape View File

@ -183,7 +183,7 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _testXmlChildFieldNames; string[] field_names = _testXmlChildFieldNames;
if (options_.Count > 0) { if (options_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 3, field_names[1], options_); output.WriteEnumArray(3, field_names[1], options_);
} }
if (hasBinary) { if (hasBinary) {
output.WriteBytes(4, field_names[0], Binary); output.WriteBytes(4, field_names[0], Binary);
@ -722,7 +722,7 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _childrenFieldNames; string[] field_names = _childrenFieldNames;
if (options_.Count > 0) { if (options_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 3, field_names[1], options_); output.WriteEnumArray(3, field_names[1], options_);
} }
if (hasBinary) { if (hasBinary) {
output.WriteBytes(4, field_names[0], Binary); output.WriteBytes(4, field_names[0], Binary);
@ -1066,7 +1066,7 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteMessage(1, field_names[0], Child); output.WriteMessage(1, field_names[0], Child);
} }
if (numbers_.Count > 0) { if (numbers_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 2, field_names[3], numbers_); output.WriteInt32Array(2, field_names[3], numbers_);
} }
if (hasText) { if (hasText) {
output.WriteString(3, field_names[4], Text); output.WriteString(3, field_names[4], Text);
@ -1079,10 +1079,10 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
extensionWriter.WriteUntil(200, output); extensionWriter.WriteUntil(200, output);
if (children_.Count > 0) { if (children_.Count > 0) {
output.WriteArray(pbd::FieldType.Group, 401, field_names[1], children_); output.WriteGroupArray(401, field_names[1], children_);
} }
if (textlines_.Count > 0) { if (textlines_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 700, field_names[5], textlines_); output.WriteStringArray(700, field_names[5], textlines_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -1299,7 +1299,7 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 18: case 18:
case 16: { case 16: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.numbers_); input.ReadInt32Array(tag, field_name, result.numbers_);
break; break;
} }
case 26: { case 26: {
@ -1319,7 +1319,7 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 5602: { case 5602: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.textlines_); input.ReadStringArray(tag, field_name, result.textlines_);
break; break;
} }
} }

338
src/ProtocolBuffers/CodedInputStream.cs
Unescape View File

@ -513,14 +513,39 @@ namespace Google.ProtocolBuffers
return true; return true;
} }
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> /// <summary>
/// Returns true if the next tag is also part of the same unpacked array /// Returns true if the next tag is also part of the same unpacked array
/// </summary> /// </summary>
private bool ContinueArray(uint currentTag, bool packed) private bool ContinueArray(uint currentTag, bool packed, int oldLimit)
{ {
if (packed) if (packed)
{ {
return !ReachedLimit; if (ReachedLimit)
{
PopLimit(oldLimit);
return false;
}
return true;
} }
string ignore; string ignore;
@ -563,239 +588,238 @@ namespace Google.ProtocolBuffers
if (ReadPrimitiveField(fieldType, ref value)) if (ReadPrimitiveField(fieldType, ref value))
list.Add(value); list.Add(value);
} }
while (ContinueArray(fieldTag, false)); while (ContinueArray(fieldTag, false, 0));
} }
} }
[CLSCompliant(false)] [CLSCompliant(false)]
public void ReadPrimitiveArray<T>(FieldType fieldType, uint fieldTag, string fieldName, ICollection<T> list) public void ReadStringArray(uint fieldTag, string fieldName, ICollection<string> list)
{ {
WireFormat.WireType normal = WireFormat.GetWireType(fieldType); string tmp = null;
WireFormat.WireType wformat = WireFormat.GetTagWireType(fieldTag); do
// 2.3 allows packed form even if the field is not declared packed.
if (normal != wformat && wformat == WireFormat.WireType.LengthDelimited)
{
int length = (int)(ReadRawVarint32() & int.MaxValue);
int limit = PushLimit(length);
//while (!ReachedLimit)
//{
// Object value = null;
// if (ReadPrimitiveField(fieldType, ref value))
// list.Add((T)value);
//}
if (!ReachedLimit)
ReadPrimitiveArrayItems(fieldType, fieldTag, list, true);
PopLimit(limit);
}
else
{ {
ReadPrimitiveArrayItems(fieldType, fieldTag, list, false); ReadString(ref tmp);
//Object value = null; list.Add(tmp);
//do } while (ContinueArray(fieldTag, false, 0));
//{
// if (ReadPrimitiveField(fieldType, ref value))
// list.Add((T)value);
//}
//while (ContinueArray(fieldTag, false));
}
} }
void ReadPrimitiveArrayItems<T>(FieldType fieldType, uint fieldTag, ICollection<T> list, bool packed) [CLSCompliant(false)]
{ public void ReadBytesArray(uint fieldTag, string fieldName, ICollection<ByteString> list)
switch (fieldType)
{
case FieldType.Double:
{ {
ICollection<double> output = (ICollection<double>)list; ByteString tmp = null;
double tmp = 0;
do do
{ {
ReadDouble(ref tmp); ReadBytes(ref tmp);
output.Add(tmp); list.Add(tmp);
} }
while (ContinueArray(fieldTag, packed)); while (ContinueArray(fieldTag, false, 0));
} }
break;
case FieldType.Float: [CLSCompliant(false)]
public void ReadBoolArray(uint fieldTag, string fieldName, ICollection<bool> list)
{ {
ICollection<float> output = (ICollection<float>)list; bool isPacked;
float tmp = 0; int holdLimit;
do if (BeginArray(fieldTag, out isPacked, out holdLimit))
{ {
ReadFloat(ref tmp); bool tmp = false;
output.Add(tmp);
}
while (ContinueArray(fieldTag, packed));
}
break;
case FieldType.Int64:
{
ICollection<long> output = (ICollection<long>)list;
long tmp = 0;
do do
{ {
ReadInt64(ref tmp); ReadBool(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.UInt64: [CLSCompliant(false)]
public void ReadInt32Array(uint fieldTag, string fieldName, ICollection<int> list)
{ {
ICollection<ulong> output = (ICollection<ulong>)list; bool isPacked;
ulong tmp = 0; int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
int tmp = 0;
do do
{ {
ReadUInt64(ref tmp); ReadInt32(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.Int32: [CLSCompliant(false)]
public void ReadSInt32Array(uint fieldTag, string fieldName, ICollection<int> list)
{
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{ {
ICollection<int> output = (ICollection<int>)list;
int tmp = 0; int tmp = 0;
do do
{ {
ReadInt32(ref tmp); ReadSInt32(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.Fixed64: [CLSCompliant(false)]
public void ReadUInt32Array(uint fieldTag, string fieldName, ICollection<uint> list)
{ {
ICollection<ulong> output = (ICollection<ulong>)list; bool isPacked;
ulong tmp = 0; int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
uint tmp = 0;
do do
{ {
ReadFixed64(ref tmp); ReadUInt32(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.Fixed32: [CLSCompliant(false)]
public void ReadFixed32Array(uint fieldTag, string fieldName, ICollection<uint> list)
{
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{ {
ICollection<uint> output = (ICollection<uint>)list;
uint tmp = 0; uint tmp = 0;
do do
{ {
ReadFixed32(ref tmp); ReadFixed32(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.Bool: [CLSCompliant(false)]
public void ReadSFixed32Array(uint fieldTag, string fieldName, ICollection<int> list)
{ {
ICollection<bool> output = (ICollection<bool>)list; bool isPacked;
bool tmp = false; int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
int tmp = 0;
do do
{ {
ReadBool(ref tmp); ReadSFixed32(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.String: [CLSCompliant(false)]
public void ReadInt64Array(uint fieldTag, string fieldName, ICollection<long> list)
{ {
ICollection<string> output = (ICollection<string>)list; bool isPacked;
string tmp = null; int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
long tmp = 0;
do do
{ {
ReadString(ref tmp); ReadInt64(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.Bytes: [CLSCompliant(false)]
public void ReadSInt64Array(uint fieldTag, string fieldName, ICollection<long> list)
{ {
ICollection<ByteString> output = (ICollection<ByteString>)list; bool isPacked;
ByteString tmp = null; int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
long tmp = 0;
do do
{ {
ReadBytes(ref tmp); ReadSInt64(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.UInt32: [CLSCompliant(false)]
public void ReadUInt64Array(uint fieldTag, string fieldName, ICollection<ulong> list)
{ {
ICollection<uint> output = (ICollection<uint>)list; bool isPacked;
uint tmp = 0; int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
ulong tmp = 0;
do do
{ {
ReadUInt32(ref tmp); ReadUInt64(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.SFixed32: [CLSCompliant(false)]
public void ReadFixed64Array(uint fieldTag, string fieldName, ICollection<ulong> list)
{ {
ICollection<int> output = (ICollection<int>)list; bool isPacked;
int tmp = 0; int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
ulong tmp = 0;
do do
{ {
ReadSFixed32(ref tmp); ReadFixed64(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.SFixed64: [CLSCompliant(false)]
public void ReadSFixed64Array(uint fieldTag, string fieldName, ICollection<long> list)
{
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{ {
ICollection<long> output = (ICollection<long>)list;
long tmp = 0; long tmp = 0;
do do
{ {
ReadSFixed64(ref tmp); ReadSFixed64(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.SInt32: [CLSCompliant(false)]
public void ReadDoubleArray(uint fieldTag, string fieldName, ICollection<double> list)
{ {
ICollection<int> output = (ICollection<int>)list; bool isPacked;
int tmp = 0; int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
double tmp = 0;
do do
{ {
ReadSInt32(ref tmp); ReadDouble(ref tmp);
output.Add(tmp); list.Add(tmp);
} while (ContinueArray(fieldTag, isPacked, holdLimit));
} }
while (ContinueArray(fieldTag, packed));
} }
break;
case FieldType.SInt64: [CLSCompliant(false)]
public void ReadFloatArray(uint fieldTag, string fieldName, ICollection<float> list)
{ {
ICollection<long> output = (ICollection<long>)list; bool isPacked;
long tmp = 0; int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
float tmp = 0;
do do
{ {
ReadSInt64(ref tmp); ReadFloat(ref tmp);
output.Add(tmp); list.Add(tmp);
} } while (ContinueArray(fieldTag, isPacked, holdLimit));
while (ContinueArray(fieldTag, packed));
}
break;
case FieldType.Group:
throw new ArgumentException("ReadPrimitiveField() cannot handle nested groups.");
case FieldType.Message:
throw new ArgumentException("ReadPrimitiveField() cannot handle embedded messages.");
// We don't handle enums because we don't know what to do if the
// value is not recognized.
case FieldType.Enum:
throw new ArgumentException("ReadPrimitiveField() cannot handle enums.");
default:
throw new ArgumentOutOfRangeException("Invalid field type " + fieldType);
} }
} }
@ -838,7 +862,7 @@ namespace Google.ProtocolBuffers
unknown.Add(unkval); unknown.Add(unkval);
} }
} }
while (ContinueArray(fieldTag, false)); while (ContinueArray(fieldTag, false, 0));
} }
} }
@ -882,7 +906,7 @@ namespace Google.ProtocolBuffers
unknown.Add(unkval); unknown.Add(unkval);
} }
} }
while (ContinueArray(fieldTag, false)); while (ContinueArray(fieldTag, false, 0));
} }
} }
@ -895,7 +919,7 @@ namespace Google.ProtocolBuffers
ReadMessage(builder, registry); ReadMessage(builder, registry);
list.Add((T)builder.WeakBuildPartial()); list.Add((T)builder.WeakBuildPartial());
} }
while (ContinueArray(fieldTag, false)); while (ContinueArray(fieldTag, false, 0));
} }
[CLSCompliant(false)] [CLSCompliant(false)]
@ -907,7 +931,7 @@ namespace Google.ProtocolBuffers
ReadGroup(WireFormat.GetTagFieldNumber(fieldTag), builder, registry); ReadGroup(WireFormat.GetTagFieldNumber(fieldTag), builder, registry);
list.Add((T)builder.WeakBuildPartial()); list.Add((T)builder.WeakBuildPartial());
} }
while (ContinueArray(fieldTag, false)); while (ContinueArray(fieldTag, false, 0));
} }
/// <summary> /// <summary>

633
src/ProtocolBuffers/CodedOutputStream.cs
Unescape View File

@ -127,7 +127,71 @@ namespace Google.ProtocolBuffers
#endregion #endregion
#region Writing of tags etc #region Writing of tags and fields
public void WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value)
{
switch (fieldType)
{
case FieldType.String:
WriteString(fieldNumber, fieldName, (string)value);
break;
case FieldType.Message:
WriteMessage(fieldNumber, fieldName, (IMessageLite)value);
break;
case FieldType.Group:
WriteGroup(fieldNumber, fieldName, (IMessageLite)value);
break;
case FieldType.Bytes:
WriteBytes(fieldNumber, fieldName, (ByteString)value);
break;
case FieldType.Bool:
WriteBool(fieldNumber, fieldName, (bool)value);
break;
case FieldType.Enum:
if (value is System.Enum)
WriteEnum(fieldNumber, fieldName, (int)value, null/*not used*/);
else
WriteEnum(fieldNumber, fieldName, ((IEnumLite)value).Number, null/*not used*/);
break;
case FieldType.Int32:
WriteInt32(fieldNumber, fieldName, (int)value);
break;
case FieldType.Int64:
WriteInt64(fieldNumber, fieldName, (long)value);
break;
case FieldType.UInt32:
WriteUInt32(fieldNumber, fieldName, (uint)value);
break;
case FieldType.UInt64:
WriteUInt64(fieldNumber, fieldName, (ulong)value);
break;
case FieldType.SInt32:
WriteSInt32(fieldNumber, fieldName, (int)value);
break;
case FieldType.SInt64:
WriteSInt64(fieldNumber, fieldName, (long)value);
break;
case FieldType.Fixed32:
WriteFixed32(fieldNumber, fieldName, (uint)value);
break;
case FieldType.Fixed64:
WriteFixed64(fieldNumber, fieldName, (ulong)value);
break;
case FieldType.SFixed32:
WriteSFixed32(fieldNumber, fieldName, (int)value);
break;
case FieldType.SFixed64:
WriteSFixed64(fieldNumber, fieldName, (long)value);
break;
case FieldType.Double:
WriteDouble(fieldNumber, fieldName, (double)value);
break;
case FieldType.Float:
WriteFloat(fieldNumber, fieldName, (float)value);
break;
}
}
/// <summary> /// <summary>
/// Writes a double field value, including tag, to the stream. /// Writes a double field value, including tag, to the stream.
@ -319,265 +383,9 @@ namespace Google.ProtocolBuffers
WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.EndGroup); WriteTag(WireFormat.MessageSetField.Item, WireFormat.WireType.EndGroup);
} }
public void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list) #endregion
{
foreach (object element in list)
WriteField(fieldType, fieldNumber, fieldName, element);
}
public void WriteArray<T>(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable<T> list)
{
switch (fieldType)
{
case FieldType.String:
foreach (string value in ((IEnumerable<string>)list))
WriteString(fieldNumber, fieldName, value);
break;
case FieldType.Message:
foreach (T value in list)
WriteMessage(fieldNumber, fieldName, (IMessageLite)value);
break;
case FieldType.Group:
foreach (T value in list)
WriteGroup(fieldNumber, fieldName, (IMessageLite)value);
break;
case FieldType.Bytes:
foreach (ByteString value in ((IEnumerable<ByteString>)list))
WriteBytes(fieldNumber, fieldName, value);
break;
case FieldType.Bool:
foreach (bool value in ((IEnumerable<bool>)list))
WriteBool(fieldNumber, fieldName, value);
break;
case FieldType.Enum:
if (default(T) is System.Enum)
{
foreach (int value in ((ICastArray)list).CastArray<int>())
WriteEnum(fieldNumber, fieldName, value, null/*not used*/);
}
else
{
foreach (T value in list)
WriteEnum(fieldNumber, fieldName, ((IEnumLite)value).Number, null/*not used*/);
}
break;
case FieldType.Int32:
foreach (int value in ((IEnumerable<int>)list))
WriteInt32(fieldNumber, fieldName, value);
break;
case FieldType.Int64:
foreach (long value in ((IEnumerable<long>)list))
WriteInt64(fieldNumber, fieldName, value);
break;
case FieldType.UInt32:
foreach (uint value in ((IEnumerable<uint>)list))
WriteUInt32(fieldNumber, fieldName, value);
break;
case FieldType.UInt64:
foreach (ulong value in ((IEnumerable<ulong>)list))
WriteUInt64(fieldNumber, fieldName, value);
break;
case FieldType.SInt32:
foreach (int value in ((IEnumerable<int>)list))
WriteSInt32(fieldNumber, fieldName, value);
break;
case FieldType.SInt64:
foreach (long value in ((IEnumerable<long>)list))
WriteSInt64(fieldNumber, fieldName, value);
break;
case FieldType.Fixed32:
foreach (uint value in ((IEnumerable<uint>)list))
WriteFixed32(fieldNumber, fieldName, value);
break;
case FieldType.Fixed64:
foreach (ulong value in ((IEnumerable<ulong>)list))
WriteFixed64(fieldNumber, fieldName, value);
break;
case FieldType.SFixed32:
foreach (int value in ((IEnumerable<int>)list))
WriteSFixed32(fieldNumber, fieldName, value);
break;
case FieldType.SFixed64:
foreach (long value in ((IEnumerable<long>)list))
WriteSFixed64(fieldNumber, fieldName, value);
break;
case FieldType.Double:
foreach (double value in ((IEnumerable<double>)list))
WriteDouble(fieldNumber, fieldName, value);
break;
case FieldType.Float:
foreach (float value in ((IEnumerable<float>)list))
WriteFloat(fieldNumber, fieldName, value);
break;
}
}
public void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list)
{
int calculatedSize = 0;
foreach (object element in list)
calculatedSize += CodedOutputStream.ComputeFieldSizeNoTag(fieldType, element);
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (object element in list)
WriteFieldNoTag(fieldType, element);
}
public void WritePackedArray<T>(FieldType fieldType, int fieldNumber, string fieldName, int calculatedSize, System.Collections.Generic.IEnumerable<T> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
switch (fieldType)
{
case FieldType.String:
foreach (string value in ((IEnumerable<string>)list))
WriteStringNoTag(value);
break;
case FieldType.Message:
foreach (T value in list)
WriteMessageNoTag((IMessageLite)value);
break;
case FieldType.Group:
foreach (T value in list)
WriteGroupNoTag((IMessageLite)value);
break;
case FieldType.Bytes:
foreach (ByteString value in ((IEnumerable<ByteString>)list))
WriteBytesNoTag(value);
break;
case FieldType.Bool:
foreach (bool value in ((IEnumerable<bool>)list))
WriteBoolNoTag(value);
break;
case FieldType.Enum:
if (default(T) is System.Enum)
{
foreach (int value in ((ICastArray)list).CastArray<int>())
WriteEnumNoTag(value);
}
else
{
foreach (T value in list)
WriteEnumNoTag(((IEnumLite)value).Number);
}
break;
case FieldType.Int32:
foreach (int value in ((IEnumerable<int>)list))
WriteInt32NoTag(value);
break;
case FieldType.Int64:
foreach (long value in ((IEnumerable<long>)list))
WriteInt64NoTag(value);
break;
case FieldType.UInt32:
foreach (uint value in ((IEnumerable<uint>)list))
WriteUInt32NoTag(value);
break;
case FieldType.UInt64:
foreach (ulong value in ((IEnumerable<ulong>)list))
WriteUInt64NoTag(value);
break;
case FieldType.SInt32:
foreach (int value in ((IEnumerable<int>)list))
WriteSInt32NoTag(value);
break;
case FieldType.SInt64:
foreach (long value in ((IEnumerable<long>)list))
WriteSInt64NoTag(value);
break;
case FieldType.Fixed32:
foreach (uint value in ((IEnumerable<uint>)list))
WriteFixed32NoTag(value);
break;
case FieldType.Fixed64:
foreach (ulong value in ((IEnumerable<ulong>)list))
WriteFixed64NoTag(value);
break;
case FieldType.SFixed32:
foreach (int value in ((IEnumerable<int>)list))
WriteSFixed32NoTag(value);
break;
case FieldType.SFixed64:
foreach (long value in ((IEnumerable<long>)list))
WriteSFixed64NoTag(value);
break;
case FieldType.Double:
foreach (double value in ((IEnumerable<double>)list))
WriteDoubleNoTag(value);
break;
case FieldType.Float:
foreach (float value in ((IEnumerable<float>)list))
WriteFloatNoTag(value);
break;
}
}
public void WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value) #region Writing of values without tags
{
switch (fieldType)
{
case FieldType.String:
WriteString(fieldNumber, fieldName, (string)value);
break;
case FieldType.Message:
WriteMessage(fieldNumber, fieldName, (IMessageLite)value);
break;
case FieldType.Group:
WriteGroup(fieldNumber, fieldName, (IMessageLite)value);
break;
case FieldType.Bytes:
WriteBytes(fieldNumber, fieldName, (ByteString)value);
break;
case FieldType.Bool:
WriteBool(fieldNumber, fieldName, (bool)value);
break;
case FieldType.Enum:
if (value is System.Enum)
WriteEnum(fieldNumber, fieldName, (int)value, null/*not used*/);
else
WriteEnum(fieldNumber, fieldName, ((IEnumLite)value).Number, null/*not used*/);
break;
case FieldType.Int32:
WriteInt32(fieldNumber, fieldName, (int) value);
break;
case FieldType.Int64:
WriteInt64(fieldNumber, fieldName, (long) value);
break;
case FieldType.UInt32:
WriteUInt32(fieldNumber, fieldName, (uint) value);
break;
case FieldType.UInt64:
WriteUInt64(fieldNumber, fieldName, (ulong) value);
break;
case FieldType.SInt32:
WriteSInt32(fieldNumber, fieldName, (int)value);
break;
case FieldType.SInt64:
WriteSInt64(fieldNumber, fieldName, (long)value);
break;
case FieldType.Fixed32:
WriteFixed32(fieldNumber, fieldName, (uint) value);
break;
case FieldType.Fixed64:
WriteFixed64(fieldNumber, fieldName, (ulong) value);
break;
case FieldType.SFixed32:
WriteSFixed32(fieldNumber, fieldName, (int) value);
break;
case FieldType.SFixed64:
WriteSFixed64(fieldNumber, fieldName, (long) value);
break;
case FieldType.Double:
WriteDouble(fieldNumber, fieldName, (double)value);
break;
case FieldType.Float:
WriteFloat(fieldNumber, fieldName, (float)value);
break;
}
}
public void WriteFieldNoTag(FieldType fieldType, object value) public void WriteFieldNoTag(FieldType fieldType, object value)
{ {
@ -643,10 +451,6 @@ namespace Google.ProtocolBuffers
} }
} }
#endregion
#region Writing of values without tags
/// <summary> /// <summary>
/// Writes a double field value, including tag, to the stream. /// Writes a double field value, including tag, to the stream.
/// </summary> /// </summary>
@ -828,6 +632,309 @@ namespace Google.ProtocolBuffers
#endregion #endregion
#region Write array members
public void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list)
{
foreach (object element in list)
WriteField(fieldType, fieldNumber, fieldName, element);
}
public void WriteGroupArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
where T : IMessageLite
{
foreach (IMessageLite value in list)
WriteGroup(fieldNumber, fieldName, value);
}
public void WriteMessageArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
where T : IMessageLite
{
foreach (IMessageLite value in list)
WriteMessage(fieldNumber, fieldName, value);
}
public void WriteStringArray(int fieldNumber, string fieldName, IEnumerable<string> list)
{
foreach (var value in list)
WriteString(fieldNumber, fieldName, value);
}
public void WriteBytesArray(int fieldNumber, string fieldName, IEnumerable<ByteString> list)
{
foreach (var value in list)
WriteBytes(fieldNumber, fieldName, value);
}
public void WriteBoolArray(int fieldNumber, string fieldName, IEnumerable<bool> list)
{
foreach (var value in list)
WriteBool(fieldNumber, fieldName, value);
}
public void WriteInt32Array(int fieldNumber, string fieldName, IEnumerable<int> list)
{
foreach (var value in list)
WriteInt32(fieldNumber, fieldName, value);
}
public void WriteSInt32Array(int fieldNumber, string fieldName, IEnumerable<int> list)
{
foreach (var value in list)
WriteSInt32(fieldNumber, fieldName, value);
}
public void WriteUInt32Array(int fieldNumber, string fieldName, IEnumerable<uint> list)
{
foreach (var value in list)
WriteUInt32(fieldNumber, fieldName, value);
}
public void WriteFixed32Array(int fieldNumber, string fieldName, IEnumerable<uint> list)
{
foreach (var value in list)
WriteFixed32(fieldNumber, fieldName, value);
}
public void WriteSFixed32Array(int fieldNumber, string fieldName, IEnumerable<int> list)
{
foreach (var value in list)
WriteSFixed32(fieldNumber, fieldName, value);
}
public void WriteInt64Array(int fieldNumber, string fieldName, IEnumerable<long> list)
{
foreach (var value in list)
WriteInt64(fieldNumber, fieldName, value);
}
public void WriteSInt64Array(int fieldNumber, string fieldName, IEnumerable<long> list)
{
foreach (var value in list)
WriteSInt64(fieldNumber, fieldName, value);
}
public void WriteUInt64Array(int fieldNumber, string fieldName, IEnumerable<ulong> list)
{
foreach (var value in list)
WriteUInt64(fieldNumber, fieldName, value);
}
public void WriteFixed64Array(int fieldNumber, string fieldName, IEnumerable<ulong> list)
{
foreach (var value in list)
WriteFixed64(fieldNumber, fieldName, value);
}
public void WriteSFixed64Array(int fieldNumber, string fieldName, IEnumerable<long> list)
{
foreach (var value in list)
WriteSFixed64(fieldNumber, fieldName, value);
}
public void WriteDoubleArray(int fieldNumber, string fieldName, IEnumerable<double> list)
{
foreach (var value in list)
WriteDouble(fieldNumber, fieldName, value);
}
public void WriteFloatArray(int fieldNumber, string fieldName, IEnumerable<float> list)
{
foreach (var value in list)
WriteFloat(fieldNumber, fieldName, value);
}
[CLSCompliant(false)]
public void WriteEnumArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
where T : struct, IComparable, IFormattable, IConvertible
{
if (list is ICastArray)
{
foreach (int value in ((ICastArray)list).CastArray<int>())
WriteEnum(fieldNumber, fieldName, value, null /*unused*/);
}
else
{
foreach (object value in list)
WriteEnum(fieldNumber, fieldName, (int) value, null /*unused*/);
}
}
#endregion
#region Write packed array members
public void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list)
{
int calculatedSize = 0;
foreach (object element in list)
calculatedSize += CodedOutputStream.ComputeFieldSizeNoTag(fieldType, element);
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (object element in list)
WriteFieldNoTag(fieldType, element);
}
public void WritePackedGroupArray<T>(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<T> list)
where T : IMessageLite
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (IMessageLite value in list)
WriteGroupNoTag(value);
}
public void WritePackedMessageArray<T>(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<T> list)
where T : IMessageLite
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (IMessageLite value in list)
WriteMessageNoTag(value);
}
public void WritePackedStringArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<string> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteStringNoTag(value);
}
public void WritePackedBytesArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<ByteString> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteBytesNoTag(value);
}
public void WritePackedBoolArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<bool> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteBoolNoTag(value);
}
public void WritePackedInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<int> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteInt32NoTag(value);
}
public void WritePackedSInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<int> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteSInt32NoTag(value);
}
public void WritePackedUInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<uint> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteUInt32NoTag(value);
}
public void WritePackedFixed32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<uint> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteFixed32NoTag(value);
}
public void WritePackedSFixed32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<int> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteSFixed32NoTag(value);
}
public void WritePackedInt64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<long> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteInt64NoTag(value);
}
public void WritePackedSInt64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<long> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteSInt64NoTag(value);
}
public void WritePackedUInt64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<ulong> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteUInt64NoTag(value);
}
public void WritePackedFixed64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<ulong> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteFixed64NoTag(value);
}
public void WritePackedSFixed64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<long> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteSFixed64NoTag(value);
}
public void WritePackedDoubleArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<double> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteDoubleNoTag(value);
}
public void WritePackedFloatArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<float> list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
foreach (var value in list)
WriteFloatNoTag(value);
}
[CLSCompliant(false)]
public void WritePackedEnumArray<T>(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<T> list)
where T : struct, IComparable, IFormattable, IConvertible
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteRawVarint32((uint)calculatedSize);
if (list is ICastArray)
{
foreach (int value in ((ICastArray)list).CastArray<int>())
WriteEnumNoTag(value);
}
else
{
foreach (object value in list)
WriteEnumNoTag((int)value);
}
}
#endregion
#region Underlying writing primitives #region Underlying writing primitives
/// <summary> /// <summary>

44
src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
Unescape View File

@ -279,7 +279,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _fileDescriptorSetFieldNames; string[] field_names = _fileDescriptorSetFieldNames;
if (file_.Count > 0) { if (file_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 1, field_names[0], file_); output.WriteMessageArray(1, field_names[0], file_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -640,19 +640,19 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
output.WriteString(2, field_names[6], Package); output.WriteString(2, field_names[6], Package);
} }
if (dependency_.Count > 0) { if (dependency_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 3, field_names[0], dependency_); output.WriteStringArray(3, field_names[0], dependency_);
} }
if (messageType_.Count > 0) { if (messageType_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 4, field_names[3], messageType_); output.WriteMessageArray(4, field_names[3], messageType_);
} }
if (enumType_.Count > 0) { if (enumType_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 5, field_names[1], enumType_); output.WriteMessageArray(5, field_names[1], enumType_);
} }
if (service_.Count > 0) { if (service_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 6, field_names[7], service_); output.WriteMessageArray(6, field_names[7], service_);
} }
if (extension_.Count > 0) { if (extension_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 7, field_names[2], extension_); output.WriteMessageArray(7, field_names[2], extension_);
} }
if (hasOptions) { if (hasOptions) {
output.WriteMessage(8, field_names[5], Options); output.WriteMessage(8, field_names[5], Options);
@ -871,7 +871,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
break; break;
} }
case 26: { case 26: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.dependency_); input.ReadStringArray(tag, field_name, result.dependency_);
break; break;
} }
case 34: { case 34: {
@ -1591,19 +1591,19 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
output.WriteString(1, field_names[4], Name); output.WriteString(1, field_names[4], Name);
} }
if (field_.Count > 0) { if (field_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 2, field_names[3], field_); output.WriteMessageArray(2, field_names[3], field_);
} }
if (nestedType_.Count > 0) { if (nestedType_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 3, field_names[5], nestedType_); output.WriteMessageArray(3, field_names[5], nestedType_);
} }
if (enumType_.Count > 0) { if (enumType_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 4, field_names[0], enumType_); output.WriteMessageArray(4, field_names[0], enumType_);
} }
if (extensionRange_.Count > 0) { if (extensionRange_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 5, field_names[2], extensionRange_); output.WriteMessageArray(5, field_names[2], extensionRange_);
} }
if (extension_.Count > 0) { if (extension_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 6, field_names[1], extension_); output.WriteMessageArray(6, field_names[1], extension_);
} }
if (hasOptions) { if (hasOptions) {
output.WriteMessage(7, field_names[6], Options); output.WriteMessage(7, field_names[6], Options);
@ -2784,7 +2784,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
output.WriteString(1, field_names[0], Name); output.WriteString(1, field_names[0], Name);
} }
if (value_.Count > 0) { if (value_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 2, field_names[2], value_); output.WriteMessageArray(2, field_names[2], value_);
} }
if (hasOptions) { if (hasOptions) {
output.WriteMessage(3, field_names[1], Options); output.WriteMessage(3, field_names[1], Options);
@ -3506,7 +3506,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
output.WriteString(1, field_names[1], Name); output.WriteString(1, field_names[1], Name);
} }
if (method_.Count > 0) { if (method_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 2, field_names[0], method_); output.WriteMessageArray(2, field_names[0], method_);
} }
if (hasOptions) { if (hasOptions) {
output.WriteMessage(3, field_names[2], Options); output.WriteMessage(3, field_names[2], Options);
@ -4354,7 +4354,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
output.WriteBool(18, field_names[6], PyGenericServices); output.WriteBool(18, field_names[6], PyGenericServices);
} }
if (uninterpretedOption_.Count > 0) { if (uninterpretedOption_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 999, field_names[7], uninterpretedOption_); output.WriteMessageArray(999, field_names[7], uninterpretedOption_);
} }
extensionWriter.WriteUntil(536870912, output); extensionWriter.WriteUntil(536870912, output);
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
@ -4856,7 +4856,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
output.WriteBool(2, field_names[1], NoStandardDescriptorAccessor); output.WriteBool(2, field_names[1], NoStandardDescriptorAccessor);
} }
if (uninterpretedOption_.Count > 0) { if (uninterpretedOption_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 999, field_names[2], uninterpretedOption_); output.WriteMessageArray(999, field_names[2], uninterpretedOption_);
} }
extensionWriter.WriteUntil(536870912, output); extensionWriter.WriteUntil(536870912, output);
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
@ -5250,7 +5250,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
output.WriteString(9, field_names[2], ExperimentalMapKey); output.WriteString(9, field_names[2], ExperimentalMapKey);
} }
if (uninterpretedOption_.Count > 0) { if (uninterpretedOption_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 999, field_names[4], uninterpretedOption_); output.WriteMessageArray(999, field_names[4], uninterpretedOption_);
} }
extensionWriter.WriteUntil(536870912, output); extensionWriter.WriteUntil(536870912, output);
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
@ -5641,7 +5641,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
string[] field_names = _enumOptionsFieldNames; string[] field_names = _enumOptionsFieldNames;
pb::ExtendableMessage<EnumOptions, EnumOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); pb::ExtendableMessage<EnumOptions, EnumOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
if (uninterpretedOption_.Count > 0) { if (uninterpretedOption_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 999, field_names[0], uninterpretedOption_); output.WriteMessageArray(999, field_names[0], uninterpretedOption_);
} }
extensionWriter.WriteUntil(536870912, output); extensionWriter.WriteUntil(536870912, output);
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
@ -5911,7 +5911,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
string[] field_names = _enumValueOptionsFieldNames; string[] field_names = _enumValueOptionsFieldNames;
pb::ExtendableMessage<EnumValueOptions, EnumValueOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); pb::ExtendableMessage<EnumValueOptions, EnumValueOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
if (uninterpretedOption_.Count > 0) { if (uninterpretedOption_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 999, field_names[0], uninterpretedOption_); output.WriteMessageArray(999, field_names[0], uninterpretedOption_);
} }
extensionWriter.WriteUntil(536870912, output); extensionWriter.WriteUntil(536870912, output);
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
@ -6181,7 +6181,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
string[] field_names = _serviceOptionsFieldNames; string[] field_names = _serviceOptionsFieldNames;
pb::ExtendableMessage<ServiceOptions, ServiceOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); pb::ExtendableMessage<ServiceOptions, ServiceOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
if (uninterpretedOption_.Count > 0) { if (uninterpretedOption_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 999, field_names[0], uninterpretedOption_); output.WriteMessageArray(999, field_names[0], uninterpretedOption_);
} }
extensionWriter.WriteUntil(536870912, output); extensionWriter.WriteUntil(536870912, output);
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
@ -6451,7 +6451,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
string[] field_names = _methodOptionsFieldNames; string[] field_names = _methodOptionsFieldNames;
pb::ExtendableMessage<MethodOptions, MethodOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this); pb::ExtendableMessage<MethodOptions, MethodOptions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
if (uninterpretedOption_.Count > 0) { if (uninterpretedOption_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 999, field_names[0], uninterpretedOption_); output.WriteMessageArray(999, field_names[0], uninterpretedOption_);
} }
extensionWriter.WriteUntil(536870912, output); extensionWriter.WriteUntil(536870912, output);
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
@ -7061,7 +7061,7 @@ namespace Google.ProtocolBuffers.DescriptorProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _uninterpretedOptionFieldNames; string[] field_names = _uninterpretedOptionFieldNames;
if (name_.Count > 0) { if (name_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 2, field_names[2], name_); output.WriteMessageArray(2, field_names[2], name_);
} }
if (hasIdentifierValue) { if (hasIdentifierValue) {
output.WriteString(3, field_names[1], IdentifierValue); output.WriteString(3, field_names[1], IdentifierValue);

52
src/ProtocolBuffers/ICodedInputStream.cs
Unescape View File

@ -146,13 +146,6 @@ namespace Google.ProtocolBuffers
[CLSCompliant(false)] [CLSCompliant(false)]
void ReadPrimitiveArray(FieldType fieldType, uint fieldTag, string fieldName, ICollection<object> list); void ReadPrimitiveArray(FieldType fieldType, uint fieldTag, string fieldName, ICollection<object> list);
/// <summary>
/// Reads an array of primitive values into the list, if the wire-type of fieldTag is length-prefixed and the
/// type is numberic, it will read a packed array.
/// </summary>
[CLSCompliant(false)]
void ReadPrimitiveArray<T>(FieldType fieldType, uint fieldTag, string fieldName, ICollection<T> list);
/// <summary> /// <summary>
/// Reads an array of primitive values into the list, if the wire-type of fieldTag is length-prefixed, it will /// Reads an array of primitive values into the list, if the wire-type of fieldTag is length-prefixed, it will
/// read a packed array. /// read a packed array.
@ -201,5 +194,50 @@ namespace Google.ProtocolBuffers
/// nothing is skipped. Otherwise, returns true.</returns> /// nothing is skipped. Otherwise, returns true.</returns>
[CLSCompliant(false)] [CLSCompliant(false)]
bool SkipField(); bool SkipField();
[CLSCompliant(false)]
void ReadStringArray(uint fieldTag, string fieldName, ICollection<string> list);
[CLSCompliant(false)]
void ReadBytesArray(uint fieldTag, string fieldName, ICollection<ByteString> list);
[CLSCompliant(false)]
void ReadBoolArray(uint fieldTag, string fieldName, ICollection<bool> list);
[CLSCompliant(false)]
void ReadInt32Array(uint fieldTag, string fieldName, ICollection<int> list);
[CLSCompliant(false)]
void ReadSInt32Array(uint fieldTag, string fieldName, ICollection<int> list);
[CLSCompliant(false)]
void ReadUInt32Array(uint fieldTag, string fieldName, ICollection<uint> list);
[CLSCompliant(false)]
void ReadFixed32Array(uint fieldTag, string fieldName, ICollection<uint> list);
[CLSCompliant(false)]
void ReadSFixed32Array(uint fieldTag, string fieldName, ICollection<int> list);
[CLSCompliant(false)]
void ReadInt64Array(uint fieldTag, string fieldName, ICollection<long> list);
[CLSCompliant(false)]
void ReadSInt64Array(uint fieldTag, string fieldName, ICollection<long> list);
[CLSCompliant(false)]
void ReadUInt64Array(uint fieldTag, string fieldName, ICollection<ulong> list);
[CLSCompliant(false)]
void ReadFixed64Array(uint fieldTag, string fieldName, ICollection<ulong> list);
[CLSCompliant(false)]
void ReadSFixed64Array(uint fieldTag, string fieldName, ICollection<long> list);
[CLSCompliant(false)]
void ReadDoubleArray(uint fieldTag, string fieldName, ICollection<double> list);
[CLSCompliant(false)]
void ReadFloatArray(uint fieldTag, string fieldName, ICollection<float> list);
} }
} }

115
src/ProtocolBuffers/ICodedOutputStream.cs
Unescape View File

@ -1,4 +1,5 @@
using System; using System;
using System.Collections.Generic;
using Google.ProtocolBuffers.Descriptors; using Google.ProtocolBuffers.Descriptors;
//Disable warning CS3010: CLS-compliant interfaces must have only CLS-compliant members //Disable warning CS3010: CLS-compliant interfaces must have only CLS-compliant members
@ -8,6 +9,15 @@ namespace Google.ProtocolBuffers
{ {
public interface ICodedOutputStream public interface ICodedOutputStream
{ {
void Flush();
[Obsolete]
void WriteUnknownGroup(int fieldNumber, string fieldName, IMessageLite value);
void WriteMessageSetExtension(int fieldNumber, string fieldName, IMessageLite value);
void WriteMessageSetExtension(int fieldNumber, string fieldName, ByteString value);
void WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value);
/// <summary> /// <summary>
/// Writes a double field value, including tag, to the stream. /// Writes a double field value, including tag, to the stream.
/// </summary> /// </summary>
@ -61,27 +71,114 @@ namespace Google.ProtocolBuffers
/// </summary> /// </summary>
void WriteGroup(int fieldNumber, string fieldName, IMessageLite value); void WriteGroup(int fieldNumber, string fieldName, IMessageLite value);
[Obsolete] /// <summary>
void WriteUnknownGroup(int fieldNumber, string fieldName, IMessageLite value); /// Writes a message field value, including tag, to the stream.
/// </summary>
void WriteMessage(int fieldNumber, string fieldName, IMessageLite value); void WriteMessage(int fieldNumber, string fieldName, IMessageLite value);
/// <summary>
/// Writes a byte array field value, including tag, to the stream.
/// </summary>
void WriteBytes(int fieldNumber, string fieldName, ByteString value); void WriteBytes(int fieldNumber, string fieldName, ByteString value);
/// <summary>
/// Writes a UInt32 field value, including tag, to the stream.
/// </summary>
[CLSCompliant(false)] [CLSCompliant(false)]
void WriteUInt32(int fieldNumber, string fieldName, uint value); void WriteUInt32(int fieldNumber, string fieldName, uint value);
/// <summary>
/// Writes an enum field value, including tag, to the stream.
/// </summary>
void WriteEnum(int fieldNumber, string fieldName, int value, object rawValue); void WriteEnum(int fieldNumber, string fieldName, int value, object rawValue);
/// <summary>
/// Writes a fixed 32-bit field value, including tag, to the stream.
/// </summary>
void WriteSFixed32(int fieldNumber, string fieldName, int value); void WriteSFixed32(int fieldNumber, string fieldName, int value);
/// <summary>
/// Writes a signed fixed 64-bit field value, including tag, to the stream.
/// </summary>
void WriteSFixed64(int fieldNumber, string fieldName, long value); void WriteSFixed64(int fieldNumber, string fieldName, long value);
/// <summary>
/// Writes a signed 32-bit field value, including tag, to the stream.
/// </summary>
void WriteSInt32(int fieldNumber, string fieldName, int value); void WriteSInt32(int fieldNumber, string fieldName, int value);
/// <summary>
/// Writes a signed 64-bit field value, including tag, to the stream.
/// </summary>
void WriteSInt64(int fieldNumber, string fieldName, long value); void WriteSInt64(int fieldNumber, string fieldName, long value);
void WriteMessageSetExtension(int fieldNumber, string fieldName, IMessageLite value);
void WriteMessageSetExtension(int fieldNumber, string fieldName, ByteString value);
void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list); void WriteArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list);
void WriteGroupArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
where T : IMessageLite;
void WriteMessageArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
where T : IMessageLite;
void WriteStringArray(int fieldNumber, string fieldName, IEnumerable<string> list);
void WriteBytesArray(int fieldNumber, string fieldName, IEnumerable<ByteString> list);
void WriteBoolArray(int fieldNumber, string fieldName, IEnumerable<bool> list);
void WriteInt32Array(int fieldNumber, string fieldName, IEnumerable<int> list);
void WriteSInt32Array(int fieldNumber, string fieldName, IEnumerable<int> list);
void WriteUInt32Array(int fieldNumber, string fieldName, IEnumerable<uint> list);
void WriteFixed32Array(int fieldNumber, string fieldName, IEnumerable<uint> list);
void WriteSFixed32Array(int fieldNumber, string fieldName, IEnumerable<int> list);
void WriteInt64Array(int fieldNumber, string fieldName, IEnumerable<long> list);
void WriteSInt64Array(int fieldNumber, string fieldName, IEnumerable<long> list);
void WriteUInt64Array(int fieldNumber, string fieldName, IEnumerable<ulong> list);
void WriteFixed64Array(int fieldNumber, string fieldName, IEnumerable<ulong> list);
void WriteSFixed64Array(int fieldNumber, string fieldName, IEnumerable<long> list);
void WriteDoubleArray(int fieldNumber, string fieldName, IEnumerable<double> list);
void WriteFloatArray(int fieldNumber, string fieldName, IEnumerable<float> list);
[CLSCompliant(false)]
void WriteEnumArray<T>(int fieldNumber, string fieldName, IEnumerable<T> list)
where T : struct, IComparable, IFormattable, IConvertible;
void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list); void WritePackedArray(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.IEnumerable list);
void WriteArray<T>(FieldType fieldType, int fieldNumber, string fieldName, System.Collections.Generic.IEnumerable<T> list);
void WritePackedArray<T>(FieldType fieldType, int fieldNumber, string fieldName, int calculatedSize, System.Collections.Generic.IEnumerable<T> list); void WritePackedBoolArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<bool> list);
void WriteField(FieldType fieldType, int fieldNumber, string fieldName, object value);
void Flush(); void WritePackedInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<int> list);
void WritePackedSInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<int> list);
void WritePackedUInt32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<uint> list);
void WritePackedFixed32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<uint> list);
void WritePackedSFixed32Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<int> list);
void WritePackedInt64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<long> list);
void WritePackedSInt64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<long> list);
void WritePackedUInt64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<ulong> list);
void WritePackedFixed64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<ulong> list);
void WritePackedSFixed64Array(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<long> list);
void WritePackedDoubleArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<double> list);
void WritePackedFloatArray(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<float> list);
[CLSCompliant(false)]
void WritePackedEnumArray<T>(int fieldNumber, string fieldName, int calculatedSize, IEnumerable<T> list)
where T : struct, IComparable, IFormattable, IConvertible;
} }
} }

8
src/ProtocolBuffersLite.Test/TestProtos/UnitTestExtrasLiteProtoFile.cs
Unescape View File

@ -1158,13 +1158,13 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteString(3, field_names[2], Email); output.WriteString(3, field_names[2], Email);
} }
if (phone_.Count > 0) { if (phone_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 4, field_names[5], phone_); output.WriteMessageArray(4, field_names[5], phone_);
} }
if (addresses_.Count > 0) { if (addresses_.Count > 0) {
output.WriteArray(pbd::FieldType.Group, 5, field_names[0], addresses_); output.WriteGroupArray(5, field_names[0], addresses_);
} }
if (codes_.Count > 0) { if (codes_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Int32, 10, field_names[1], codesMemoizedSerializedSize, codes_); output.WritePackedInt32Array(10, field_names[1], codesMemoizedSerializedSize, codes_);
} }
extensionWriter.WriteUntil(200, output); extensionWriter.WriteUntil(200, output);
} }
@ -1414,7 +1414,7 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 82: case 82:
case 80: { case 80: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.codes_); input.ReadInt32Array(tag, field_name, result.codes_);
break; break;
} }
} }

190
src/ProtocolBuffersLite.Test/TestProtos/UnitTestLiteProtoFile.cs
Unescape View File

@ -2773,76 +2773,76 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteString(25, field_names[22], OptionalCord); output.WriteString(25, field_names[22], OptionalCord);
} }
if (repeatedInt32_.Count > 0) { if (repeatedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 31, field_names[55], repeatedInt32_); output.WriteInt32Array(31, field_names[55], repeatedInt32_);
} }
if (repeatedInt64_.Count > 0) { if (repeatedInt64_.Count > 0) {
output.WriteArray(pbd::FieldType.Int64, 32, field_names[56], repeatedInt64_); output.WriteInt64Array(32, field_names[56], repeatedInt64_);
} }
if (repeatedUint32_.Count > 0) { if (repeatedUint32_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt32, 33, field_names[65], repeatedUint32_); output.WriteUInt32Array(33, field_names[65], repeatedUint32_);
} }
if (repeatedUint64_.Count > 0) { if (repeatedUint64_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt64, 34, field_names[66], repeatedUint64_); output.WriteUInt64Array(34, field_names[66], repeatedUint64_);
} }
if (repeatedSint32_.Count > 0) { if (repeatedSint32_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt32, 35, field_names[61], repeatedSint32_); output.WriteSInt32Array(35, field_names[61], repeatedSint32_);
} }
if (repeatedSint64_.Count > 0) { if (repeatedSint64_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt64, 36, field_names[62], repeatedSint64_); output.WriteSInt64Array(36, field_names[62], repeatedSint64_);
} }
if (repeatedFixed32_.Count > 0) { if (repeatedFixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed32, 37, field_names[48], repeatedFixed32_); output.WriteFixed32Array(37, field_names[48], repeatedFixed32_);
} }
if (repeatedFixed64_.Count > 0) { if (repeatedFixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed64, 38, field_names[49], repeatedFixed64_); output.WriteFixed64Array(38, field_names[49], repeatedFixed64_);
} }
if (repeatedSfixed32_.Count > 0) { if (repeatedSfixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed32, 39, field_names[59], repeatedSfixed32_); output.WriteSFixed32Array(39, field_names[59], repeatedSfixed32_);
} }
if (repeatedSfixed64_.Count > 0) { if (repeatedSfixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed64, 40, field_names[60], repeatedSfixed64_); output.WriteSFixed64Array(40, field_names[60], repeatedSfixed64_);
} }
if (repeatedFloat_.Count > 0) { if (repeatedFloat_.Count > 0) {
output.WriteArray(pbd::FieldType.Float, 41, field_names[50], repeatedFloat_); output.WriteFloatArray(41, field_names[50], repeatedFloat_);
} }
if (repeatedDouble_.Count > 0) { if (repeatedDouble_.Count > 0) {
output.WriteArray(pbd::FieldType.Double, 42, field_names[47], repeatedDouble_); output.WriteDoubleArray(42, field_names[47], repeatedDouble_);
} }
if (repeatedBool_.Count > 0) { if (repeatedBool_.Count > 0) {
output.WriteArray(pbd::FieldType.Bool, 43, field_names[44], repeatedBool_); output.WriteBoolArray(43, field_names[44], repeatedBool_);
} }
if (repeatedString_.Count > 0) { if (repeatedString_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 44, field_names[63], repeatedString_); output.WriteStringArray(44, field_names[63], repeatedString_);
} }
if (repeatedBytes_.Count > 0) { if (repeatedBytes_.Count > 0) {
output.WriteArray(pbd::FieldType.Bytes, 45, field_names[45], repeatedBytes_); output.WriteBytesArray(45, field_names[45], repeatedBytes_);
} }
if (repeatedGroup_.Count > 0) { if (repeatedGroup_.Count > 0) {
output.WriteArray(pbd::FieldType.Group, 46, field_names[67], repeatedGroup_); output.WriteGroupArray(46, field_names[67], repeatedGroup_);
} }
if (repeatedNestedMessage_.Count > 0) { if (repeatedNestedMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 48, field_names[58], repeatedNestedMessage_); output.WriteMessageArray(48, field_names[58], repeatedNestedMessage_);
} }
if (repeatedForeignMessage_.Count > 0) { if (repeatedForeignMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 49, field_names[52], repeatedForeignMessage_); output.WriteMessageArray(49, field_names[52], repeatedForeignMessage_);
} }
if (repeatedImportMessage_.Count > 0) { if (repeatedImportMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 50, field_names[54], repeatedImportMessage_); output.WriteMessageArray(50, field_names[54], repeatedImportMessage_);
} }
if (repeatedNestedEnum_.Count > 0) { if (repeatedNestedEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 51, field_names[57], repeatedNestedEnum_); output.WriteEnumArray(51, field_names[57], repeatedNestedEnum_);
} }
if (repeatedForeignEnum_.Count > 0) { if (repeatedForeignEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 52, field_names[51], repeatedForeignEnum_); output.WriteEnumArray(52, field_names[51], repeatedForeignEnum_);
} }
if (repeatedImportEnum_.Count > 0) { if (repeatedImportEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 53, field_names[53], repeatedImportEnum_); output.WriteEnumArray(53, field_names[53], repeatedImportEnum_);
} }
if (repeatedStringPiece_.Count > 0) { if (repeatedStringPiece_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 54, field_names[64], repeatedStringPiece_); output.WriteStringArray(54, field_names[64], repeatedStringPiece_);
} }
if (repeatedCord_.Count > 0) { if (repeatedCord_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 55, field_names[46], repeatedCord_); output.WriteStringArray(55, field_names[46], repeatedCord_);
} }
if (hasDefaultInt32) { if (hasDefaultInt32) {
output.WriteInt32(61, field_names[9], DefaultInt32); output.WriteInt32(61, field_names[9], DefaultInt32);
@ -3980,75 +3980,75 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 250: case 250:
case 248: { case 248: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.repeatedInt32_); input.ReadInt32Array(tag, field_name, result.repeatedInt32_);
break; break;
} }
case 258: case 258:
case 256: { case 256: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.repeatedInt64_); input.ReadInt64Array(tag, field_name, result.repeatedInt64_);
break; break;
} }
case 266: case 266:
case 264: { case 264: {
input.ReadPrimitiveArray(pbd::FieldType.UInt32, tag, field_name, result.repeatedUint32_); input.ReadUInt32Array(tag, field_name, result.repeatedUint32_);
break; break;
} }
case 274: case 274:
case 272: { case 272: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.repeatedUint64_); input.ReadUInt64Array(tag, field_name, result.repeatedUint64_);
break; break;
} }
case 282: case 282:
case 280: { case 280: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.repeatedSint32_); input.ReadSInt32Array(tag, field_name, result.repeatedSint32_);
break; break;
} }
case 290: case 290:
case 288: { case 288: {
input.ReadPrimitiveArray(pbd::FieldType.SInt64, tag, field_name, result.repeatedSint64_); input.ReadSInt64Array(tag, field_name, result.repeatedSint64_);
break; break;
} }
case 298: case 298:
case 301: { case 301: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.repeatedFixed32_); input.ReadFixed32Array(tag, field_name, result.repeatedFixed32_);
break; break;
} }
case 306: case 306:
case 305: { case 305: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.repeatedFixed64_); input.ReadFixed64Array(tag, field_name, result.repeatedFixed64_);
break; break;
} }
case 314: case 314:
case 317: { case 317: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed32, tag, field_name, result.repeatedSfixed32_); input.ReadSFixed32Array(tag, field_name, result.repeatedSfixed32_);
break; break;
} }
case 322: case 322:
case 321: { case 321: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed64, tag, field_name, result.repeatedSfixed64_); input.ReadSFixed64Array(tag, field_name, result.repeatedSfixed64_);
break; break;
} }
case 330: case 330:
case 333: { case 333: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.repeatedFloat_); input.ReadFloatArray(tag, field_name, result.repeatedFloat_);
break; break;
} }
case 338: case 338:
case 337: { case 337: {
input.ReadPrimitiveArray(pbd::FieldType.Double, tag, field_name, result.repeatedDouble_); input.ReadDoubleArray(tag, field_name, result.repeatedDouble_);
break; break;
} }
case 346: case 346:
case 344: { case 344: {
input.ReadPrimitiveArray(pbd::FieldType.Bool, tag, field_name, result.repeatedBool_); input.ReadBoolArray(tag, field_name, result.repeatedBool_);
break; break;
} }
case 354: { case 354: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedString_); input.ReadStringArray(tag, field_name, result.repeatedString_);
break; break;
} }
case 362: { case 362: {
input.ReadPrimitiveArray(pbd::FieldType.Bytes, tag, field_name, result.repeatedBytes_); input.ReadBytesArray(tag, field_name, result.repeatedBytes_);
break; break;
} }
case 371: { case 371: {
@ -4086,11 +4086,11 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 434: { case 434: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedStringPiece_); input.ReadStringArray(tag, field_name, result.repeatedStringPiece_);
break; break;
} }
case 442: { case 442: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedCord_); input.ReadStringArray(tag, field_name, result.repeatedCord_);
break; break;
} }
case 488: { case 488: {
@ -6234,46 +6234,46 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _testPackedTypesLiteFieldNames; string[] field_names = _testPackedTypesLiteFieldNames;
if (packedInt32_.Count > 0) { if (packedInt32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Int32, 90, field_names[6], packedInt32MemoizedSerializedSize, packedInt32_); output.WritePackedInt32Array(90, field_names[6], packedInt32MemoizedSerializedSize, packedInt32_);
} }
if (packedInt64_.Count > 0) { if (packedInt64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Int64, 91, field_names[7], packedInt64MemoizedSerializedSize, packedInt64_); output.WritePackedInt64Array(91, field_names[7], packedInt64MemoizedSerializedSize, packedInt64_);
} }
if (packedUint32_.Count > 0) { if (packedUint32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.UInt32, 92, field_names[12], packedUint32MemoizedSerializedSize, packedUint32_); output.WritePackedUInt32Array(92, field_names[12], packedUint32MemoizedSerializedSize, packedUint32_);
} }
if (packedUint64_.Count > 0) { if (packedUint64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.UInt64, 93, field_names[13], packedUint64MemoizedSerializedSize, packedUint64_); output.WritePackedUInt64Array(93, field_names[13], packedUint64MemoizedSerializedSize, packedUint64_);
} }
if (packedSint32_.Count > 0) { if (packedSint32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SInt32, 94, field_names[10], packedSint32MemoizedSerializedSize, packedSint32_); output.WritePackedSInt32Array(94, field_names[10], packedSint32MemoizedSerializedSize, packedSint32_);
} }
if (packedSint64_.Count > 0) { if (packedSint64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SInt64, 95, field_names[11], packedSint64MemoizedSerializedSize, packedSint64_); output.WritePackedSInt64Array(95, field_names[11], packedSint64MemoizedSerializedSize, packedSint64_);
} }
if (packedFixed32_.Count > 0) { if (packedFixed32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Fixed32, 96, field_names[3], packedFixed32MemoizedSerializedSize, packedFixed32_); output.WritePackedFixed32Array(96, field_names[3], packedFixed32MemoizedSerializedSize, packedFixed32_);
} }
if (packedFixed64_.Count > 0) { if (packedFixed64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Fixed64, 97, field_names[4], packedFixed64MemoizedSerializedSize, packedFixed64_); output.WritePackedFixed64Array(97, field_names[4], packedFixed64MemoizedSerializedSize, packedFixed64_);
} }
if (packedSfixed32_.Count > 0) { if (packedSfixed32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SFixed32, 98, field_names[8], packedSfixed32MemoizedSerializedSize, packedSfixed32_); output.WritePackedSFixed32Array(98, field_names[8], packedSfixed32MemoizedSerializedSize, packedSfixed32_);
} }
if (packedSfixed64_.Count > 0) { if (packedSfixed64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SFixed64, 99, field_names[9], packedSfixed64MemoizedSerializedSize, packedSfixed64_); output.WritePackedSFixed64Array(99, field_names[9], packedSfixed64MemoizedSerializedSize, packedSfixed64_);
} }
if (packedFloat_.Count > 0) { if (packedFloat_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Float, 100, field_names[5], packedFloatMemoizedSerializedSize, packedFloat_); output.WritePackedFloatArray(100, field_names[5], packedFloatMemoizedSerializedSize, packedFloat_);
} }
if (packedDouble_.Count > 0) { if (packedDouble_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Double, 101, field_names[1], packedDoubleMemoizedSerializedSize, packedDouble_); output.WritePackedDoubleArray(101, field_names[1], packedDoubleMemoizedSerializedSize, packedDouble_);
} }
if (packedBool_.Count > 0) { if (packedBool_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Bool, 102, field_names[0], packedBoolMemoizedSerializedSize, packedBool_); output.WritePackedBoolArray(102, field_names[0], packedBoolMemoizedSerializedSize, packedBool_);
} }
if (packedEnum_.Count > 0) { if (packedEnum_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Enum, 103, field_names[2], packedEnumMemoizedSerializedSize, packedEnum_); output.WritePackedEnumArray(103, field_names[2], packedEnumMemoizedSerializedSize, packedEnum_);
} }
} }
@ -6704,67 +6704,67 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 722: case 722:
case 720: { case 720: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.packedInt32_); input.ReadInt32Array(tag, field_name, result.packedInt32_);
break; break;
} }
case 730: case 730:
case 728: { case 728: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.packedInt64_); input.ReadInt64Array(tag, field_name, result.packedInt64_);
break; break;
} }
case 738: case 738:
case 736: { case 736: {
input.ReadPrimitiveArray(pbd::FieldType.UInt32, tag, field_name, result.packedUint32_); input.ReadUInt32Array(tag, field_name, result.packedUint32_);
break; break;
} }
case 746: case 746:
case 744: { case 744: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.packedUint64_); input.ReadUInt64Array(tag, field_name, result.packedUint64_);
break; break;
} }
case 754: case 754:
case 752: { case 752: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.packedSint32_); input.ReadSInt32Array(tag, field_name, result.packedSint32_);
break; break;
} }
case 762: case 762:
case 760: { case 760: {
input.ReadPrimitiveArray(pbd::FieldType.SInt64, tag, field_name, result.packedSint64_); input.ReadSInt64Array(tag, field_name, result.packedSint64_);
break; break;
} }
case 770: case 770:
case 773: { case 773: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.packedFixed32_); input.ReadFixed32Array(tag, field_name, result.packedFixed32_);
break; break;
} }
case 778: case 778:
case 777: { case 777: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.packedFixed64_); input.ReadFixed64Array(tag, field_name, result.packedFixed64_);
break; break;
} }
case 786: case 786:
case 789: { case 789: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed32, tag, field_name, result.packedSfixed32_); input.ReadSFixed32Array(tag, field_name, result.packedSfixed32_);
break; break;
} }
case 794: case 794:
case 793: { case 793: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed64, tag, field_name, result.packedSfixed64_); input.ReadSFixed64Array(tag, field_name, result.packedSfixed64_);
break; break;
} }
case 802: case 802:
case 805: { case 805: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.packedFloat_); input.ReadFloatArray(tag, field_name, result.packedFloat_);
break; break;
} }
case 810: case 810:
case 809: { case 809: {
input.ReadPrimitiveArray(pbd::FieldType.Double, tag, field_name, result.packedDouble_); input.ReadDoubleArray(tag, field_name, result.packedDouble_);
break; break;
} }
case 818: case 818:
case 816: { case 816: {
input.ReadPrimitiveArray(pbd::FieldType.Bool, tag, field_name, result.packedBool_); input.ReadBoolArray(tag, field_name, result.packedBool_);
break; break;
} }
case 826: case 826:
@ -7374,46 +7374,46 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _testUnpackedTypesLiteFieldNames; string[] field_names = _testUnpackedTypesLiteFieldNames;
if (unpackedInt32_.Count > 0) { if (unpackedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 90, field_names[6], unpackedInt32_); output.WriteInt32Array(90, field_names[6], unpackedInt32_);
} }
if (unpackedInt64_.Count > 0) { if (unpackedInt64_.Count > 0) {
output.WriteArray(pbd::FieldType.Int64, 91, field_names[7], unpackedInt64_); output.WriteInt64Array(91, field_names[7], unpackedInt64_);
} }
if (unpackedUint32_.Count > 0) { if (unpackedUint32_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt32, 92, field_names[12], unpackedUint32_); output.WriteUInt32Array(92, field_names[12], unpackedUint32_);
} }
if (unpackedUint64_.Count > 0) { if (unpackedUint64_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt64, 93, field_names[13], unpackedUint64_); output.WriteUInt64Array(93, field_names[13], unpackedUint64_);
} }
if (unpackedSint32_.Count > 0) { if (unpackedSint32_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt32, 94, field_names[10], unpackedSint32_); output.WriteSInt32Array(94, field_names[10], unpackedSint32_);
} }
if (unpackedSint64_.Count > 0) { if (unpackedSint64_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt64, 95, field_names[11], unpackedSint64_); output.WriteSInt64Array(95, field_names[11], unpackedSint64_);
} }
if (unpackedFixed32_.Count > 0) { if (unpackedFixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed32, 96, field_names[3], unpackedFixed32_); output.WriteFixed32Array(96, field_names[3], unpackedFixed32_);
} }
if (unpackedFixed64_.Count > 0) { if (unpackedFixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed64, 97, field_names[4], unpackedFixed64_); output.WriteFixed64Array(97, field_names[4], unpackedFixed64_);
} }
if (unpackedSfixed32_.Count > 0) { if (unpackedSfixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed32, 98, field_names[8], unpackedSfixed32_); output.WriteSFixed32Array(98, field_names[8], unpackedSfixed32_);
} }
if (unpackedSfixed64_.Count > 0) { if (unpackedSfixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed64, 99, field_names[9], unpackedSfixed64_); output.WriteSFixed64Array(99, field_names[9], unpackedSfixed64_);
} }
if (unpackedFloat_.Count > 0) { if (unpackedFloat_.Count > 0) {
output.WriteArray(pbd::FieldType.Float, 100, field_names[5], unpackedFloat_); output.WriteFloatArray(100, field_names[5], unpackedFloat_);
} }
if (unpackedDouble_.Count > 0) { if (unpackedDouble_.Count > 0) {
output.WriteArray(pbd::FieldType.Double, 101, field_names[1], unpackedDouble_); output.WriteDoubleArray(101, field_names[1], unpackedDouble_);
} }
if (unpackedBool_.Count > 0) { if (unpackedBool_.Count > 0) {
output.WriteArray(pbd::FieldType.Bool, 102, field_names[0], unpackedBool_); output.WriteBoolArray(102, field_names[0], unpackedBool_);
} }
if (unpackedEnum_.Count > 0) { if (unpackedEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 103, field_names[2], unpackedEnum_); output.WriteEnumArray(103, field_names[2], unpackedEnum_);
} }
} }
@ -7803,67 +7803,67 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 722: case 722:
case 720: { case 720: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.unpackedInt32_); input.ReadInt32Array(tag, field_name, result.unpackedInt32_);
break; break;
} }
case 730: case 730:
case 728: { case 728: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.unpackedInt64_); input.ReadInt64Array(tag, field_name, result.unpackedInt64_);
break; break;
} }
case 738: case 738:
case 736: { case 736: {
input.ReadPrimitiveArray(pbd::FieldType.UInt32, tag, field_name, result.unpackedUint32_); input.ReadUInt32Array(tag, field_name, result.unpackedUint32_);
break; break;
} }
case 746: case 746:
case 744: { case 744: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.unpackedUint64_); input.ReadUInt64Array(tag, field_name, result.unpackedUint64_);
break; break;
} }
case 754: case 754:
case 752: { case 752: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.unpackedSint32_); input.ReadSInt32Array(tag, field_name, result.unpackedSint32_);
break; break;
} }
case 762: case 762:
case 760: { case 760: {
input.ReadPrimitiveArray(pbd::FieldType.SInt64, tag, field_name, result.unpackedSint64_); input.ReadSInt64Array(tag, field_name, result.unpackedSint64_);
break; break;
} }
case 770: case 770:
case 773: { case 773: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.unpackedFixed32_); input.ReadFixed32Array(tag, field_name, result.unpackedFixed32_);
break; break;
} }
case 778: case 778:
case 777: { case 777: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.unpackedFixed64_); input.ReadFixed64Array(tag, field_name, result.unpackedFixed64_);
break; break;
} }
case 786: case 786:
case 789: { case 789: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed32, tag, field_name, result.unpackedSfixed32_); input.ReadSFixed32Array(tag, field_name, result.unpackedSfixed32_);
break; break;
} }
case 794: case 794:
case 793: { case 793: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed64, tag, field_name, result.unpackedSfixed64_); input.ReadSFixed64Array(tag, field_name, result.unpackedSfixed64_);
break; break;
} }
case 802: case 802:
case 805: { case 805: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.unpackedFloat_); input.ReadFloatArray(tag, field_name, result.unpackedFloat_);
break; break;
} }
case 810: case 810:
case 809: { case 809: {
input.ReadPrimitiveArray(pbd::FieldType.Double, tag, field_name, result.unpackedDouble_); input.ReadDoubleArray(tag, field_name, result.unpackedDouble_);
break; break;
} }
case 818: case 818:
case 816: { case 816: {
input.ReadPrimitiveArray(pbd::FieldType.Bool, tag, field_name, result.unpackedBool_); input.ReadBoolArray(tag, field_name, result.unpackedBool_);
break; break;
} }
case 826: case 826:

250
src/ProtocolBuffersLite.Test/TestProtos/UnitTestProtoFile.cs
Unescape View File

@ -2702,76 +2702,76 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteString(25, field_names[22], OptionalCord); output.WriteString(25, field_names[22], OptionalCord);
} }
if (repeatedInt32_.Count > 0) { if (repeatedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 31, field_names[55], repeatedInt32_); output.WriteInt32Array(31, field_names[55], repeatedInt32_);
} }
if (repeatedInt64_.Count > 0) { if (repeatedInt64_.Count > 0) {
output.WriteArray(pbd::FieldType.Int64, 32, field_names[56], repeatedInt64_); output.WriteInt64Array(32, field_names[56], repeatedInt64_);
} }
if (repeatedUint32_.Count > 0) { if (repeatedUint32_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt32, 33, field_names[65], repeatedUint32_); output.WriteUInt32Array(33, field_names[65], repeatedUint32_);
} }
if (repeatedUint64_.Count > 0) { if (repeatedUint64_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt64, 34, field_names[66], repeatedUint64_); output.WriteUInt64Array(34, field_names[66], repeatedUint64_);
} }
if (repeatedSint32_.Count > 0) { if (repeatedSint32_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt32, 35, field_names[61], repeatedSint32_); output.WriteSInt32Array(35, field_names[61], repeatedSint32_);
} }
if (repeatedSint64_.Count > 0) { if (repeatedSint64_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt64, 36, field_names[62], repeatedSint64_); output.WriteSInt64Array(36, field_names[62], repeatedSint64_);
} }
if (repeatedFixed32_.Count > 0) { if (repeatedFixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed32, 37, field_names[48], repeatedFixed32_); output.WriteFixed32Array(37, field_names[48], repeatedFixed32_);
} }
if (repeatedFixed64_.Count > 0) { if (repeatedFixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed64, 38, field_names[49], repeatedFixed64_); output.WriteFixed64Array(38, field_names[49], repeatedFixed64_);
} }
if (repeatedSfixed32_.Count > 0) { if (repeatedSfixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed32, 39, field_names[59], repeatedSfixed32_); output.WriteSFixed32Array(39, field_names[59], repeatedSfixed32_);
} }
if (repeatedSfixed64_.Count > 0) { if (repeatedSfixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed64, 40, field_names[60], repeatedSfixed64_); output.WriteSFixed64Array(40, field_names[60], repeatedSfixed64_);
} }
if (repeatedFloat_.Count > 0) { if (repeatedFloat_.Count > 0) {
output.WriteArray(pbd::FieldType.Float, 41, field_names[50], repeatedFloat_); output.WriteFloatArray(41, field_names[50], repeatedFloat_);
} }
if (repeatedDouble_.Count > 0) { if (repeatedDouble_.Count > 0) {
output.WriteArray(pbd::FieldType.Double, 42, field_names[47], repeatedDouble_); output.WriteDoubleArray(42, field_names[47], repeatedDouble_);
} }
if (repeatedBool_.Count > 0) { if (repeatedBool_.Count > 0) {
output.WriteArray(pbd::FieldType.Bool, 43, field_names[44], repeatedBool_); output.WriteBoolArray(43, field_names[44], repeatedBool_);
} }
if (repeatedString_.Count > 0) { if (repeatedString_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 44, field_names[63], repeatedString_); output.WriteStringArray(44, field_names[63], repeatedString_);
} }
if (repeatedBytes_.Count > 0) { if (repeatedBytes_.Count > 0) {
output.WriteArray(pbd::FieldType.Bytes, 45, field_names[45], repeatedBytes_); output.WriteBytesArray(45, field_names[45], repeatedBytes_);
} }
if (repeatedGroup_.Count > 0) { if (repeatedGroup_.Count > 0) {
output.WriteArray(pbd::FieldType.Group, 46, field_names[67], repeatedGroup_); output.WriteGroupArray(46, field_names[67], repeatedGroup_);
} }
if (repeatedNestedMessage_.Count > 0) { if (repeatedNestedMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 48, field_names[58], repeatedNestedMessage_); output.WriteMessageArray(48, field_names[58], repeatedNestedMessage_);
} }
if (repeatedForeignMessage_.Count > 0) { if (repeatedForeignMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 49, field_names[52], repeatedForeignMessage_); output.WriteMessageArray(49, field_names[52], repeatedForeignMessage_);
} }
if (repeatedImportMessage_.Count > 0) { if (repeatedImportMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 50, field_names[54], repeatedImportMessage_); output.WriteMessageArray(50, field_names[54], repeatedImportMessage_);
} }
if (repeatedNestedEnum_.Count > 0) { if (repeatedNestedEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 51, field_names[57], repeatedNestedEnum_); output.WriteEnumArray(51, field_names[57], repeatedNestedEnum_);
} }
if (repeatedForeignEnum_.Count > 0) { if (repeatedForeignEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 52, field_names[51], repeatedForeignEnum_); output.WriteEnumArray(52, field_names[51], repeatedForeignEnum_);
} }
if (repeatedImportEnum_.Count > 0) { if (repeatedImportEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 53, field_names[53], repeatedImportEnum_); output.WriteEnumArray(53, field_names[53], repeatedImportEnum_);
} }
if (repeatedStringPiece_.Count > 0) { if (repeatedStringPiece_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 54, field_names[64], repeatedStringPiece_); output.WriteStringArray(54, field_names[64], repeatedStringPiece_);
} }
if (repeatedCord_.Count > 0) { if (repeatedCord_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 55, field_names[46], repeatedCord_); output.WriteStringArray(55, field_names[46], repeatedCord_);
} }
if (hasDefaultInt32) { if (hasDefaultInt32) {
output.WriteInt32(61, field_names[9], DefaultInt32); output.WriteInt32(61, field_names[9], DefaultInt32);
@ -3646,75 +3646,75 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 250: case 250:
case 248: { case 248: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.repeatedInt32_); input.ReadInt32Array(tag, field_name, result.repeatedInt32_);
break; break;
} }
case 258: case 258:
case 256: { case 256: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.repeatedInt64_); input.ReadInt64Array(tag, field_name, result.repeatedInt64_);
break; break;
} }
case 266: case 266:
case 264: { case 264: {
input.ReadPrimitiveArray(pbd::FieldType.UInt32, tag, field_name, result.repeatedUint32_); input.ReadUInt32Array(tag, field_name, result.repeatedUint32_);
break; break;
} }
case 274: case 274:
case 272: { case 272: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.repeatedUint64_); input.ReadUInt64Array(tag, field_name, result.repeatedUint64_);
break; break;
} }
case 282: case 282:
case 280: { case 280: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.repeatedSint32_); input.ReadSInt32Array(tag, field_name, result.repeatedSint32_);
break; break;
} }
case 290: case 290:
case 288: { case 288: {
input.ReadPrimitiveArray(pbd::FieldType.SInt64, tag, field_name, result.repeatedSint64_); input.ReadSInt64Array(tag, field_name, result.repeatedSint64_);
break; break;
} }
case 298: case 298:
case 301: { case 301: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.repeatedFixed32_); input.ReadFixed32Array(tag, field_name, result.repeatedFixed32_);
break; break;
} }
case 306: case 306:
case 305: { case 305: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.repeatedFixed64_); input.ReadFixed64Array(tag, field_name, result.repeatedFixed64_);
break; break;
} }
case 314: case 314:
case 317: { case 317: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed32, tag, field_name, result.repeatedSfixed32_); input.ReadSFixed32Array(tag, field_name, result.repeatedSfixed32_);
break; break;
} }
case 322: case 322:
case 321: { case 321: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed64, tag, field_name, result.repeatedSfixed64_); input.ReadSFixed64Array(tag, field_name, result.repeatedSfixed64_);
break; break;
} }
case 330: case 330:
case 333: { case 333: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.repeatedFloat_); input.ReadFloatArray(tag, field_name, result.repeatedFloat_);
break; break;
} }
case 338: case 338:
case 337: { case 337: {
input.ReadPrimitiveArray(pbd::FieldType.Double, tag, field_name, result.repeatedDouble_); input.ReadDoubleArray(tag, field_name, result.repeatedDouble_);
break; break;
} }
case 346: case 346:
case 344: { case 344: {
input.ReadPrimitiveArray(pbd::FieldType.Bool, tag, field_name, result.repeatedBool_); input.ReadBoolArray(tag, field_name, result.repeatedBool_);
break; break;
} }
case 354: { case 354: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedString_); input.ReadStringArray(tag, field_name, result.repeatedString_);
break; break;
} }
case 362: { case 362: {
input.ReadPrimitiveArray(pbd::FieldType.Bytes, tag, field_name, result.repeatedBytes_); input.ReadBytesArray(tag, field_name, result.repeatedBytes_);
break; break;
} }
case 371: { case 371: {
@ -3776,11 +3776,11 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 434: { case 434: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedStringPiece_); input.ReadStringArray(tag, field_name, result.repeatedStringPiece_);
break; break;
} }
case 442: { case 442: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedCord_); input.ReadStringArray(tag, field_name, result.repeatedCord_);
break; break;
} }
case 488: { case 488: {
@ -8485,7 +8485,7 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteMessage(1, field_names[1], OptionalMessage); output.WriteMessage(1, field_names[1], OptionalMessage);
} }
if (repeatedMessage_.Count > 0) { if (repeatedMessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 2, field_names[2], repeatedMessage_); output.WriteMessageArray(2, field_names[2], repeatedMessage_);
} }
if (hasDummy) { if (hasDummy) {
output.WriteInt32(3, field_names[0], Dummy); output.WriteInt32(3, field_names[0], Dummy);
@ -11742,10 +11742,10 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _nestedMessageFieldNames; string[] field_names = _nestedMessageFieldNames;
if (nestedmessageRepeatedInt32_.Count > 0) { if (nestedmessageRepeatedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 1, field_names[1], nestedmessageRepeatedInt32_); output.WriteInt32Array(1, field_names[1], nestedmessageRepeatedInt32_);
} }
if (nestedmessageRepeatedForeignmessage_.Count > 0) { if (nestedmessageRepeatedForeignmessage_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 2, field_names[0], nestedmessageRepeatedForeignmessage_); output.WriteMessageArray(2, field_names[0], nestedmessageRepeatedForeignmessage_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -11915,7 +11915,7 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 10: case 10:
case 8: { case 8: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.nestedmessageRepeatedInt32_); input.ReadInt32Array(tag, field_name, result.nestedmessageRepeatedInt32_);
break; break;
} }
case 18: { case 18: {
@ -12426,22 +12426,22 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteString(6, field_names[0], CordField); output.WriteString(6, field_names[0], CordField);
} }
if (repeatedPrimitiveField_.Count > 0) { if (repeatedPrimitiveField_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 7, field_names[7], repeatedPrimitiveField_); output.WriteInt32Array(7, field_names[7], repeatedPrimitiveField_);
} }
if (repeatedStringField_.Count > 0) { if (repeatedStringField_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 8, field_names[8], repeatedStringField_); output.WriteStringArray(8, field_names[8], repeatedStringField_);
} }
if (repeatedEnumField_.Count > 0) { if (repeatedEnumField_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 9, field_names[5], repeatedEnumField_); output.WriteEnumArray(9, field_names[5], repeatedEnumField_);
} }
if (repeatedMessageField_.Count > 0) { if (repeatedMessageField_.Count > 0) {
output.WriteArray(pbd::FieldType.Message, 10, field_names[6], repeatedMessageField_); output.WriteMessageArray(10, field_names[6], repeatedMessageField_);
} }
if (repeatedStringPieceField_.Count > 0) { if (repeatedStringPieceField_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 11, field_names[9], repeatedStringPieceField_); output.WriteStringArray(11, field_names[9], repeatedStringPieceField_);
} }
if (repeatedCordField_.Count > 0) { if (repeatedCordField_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 12, field_names[4], repeatedCordField_); output.WriteStringArray(12, field_names[4], repeatedCordField_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -12734,11 +12734,11 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 58: case 58:
case 56: { case 56: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.repeatedPrimitiveField_); input.ReadInt32Array(tag, field_name, result.repeatedPrimitiveField_);
break; break;
} }
case 66: { case 66: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedStringField_); input.ReadStringArray(tag, field_name, result.repeatedStringField_);
break; break;
} }
case 74: case 74:
@ -12760,11 +12760,11 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 90: { case 90: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedStringPieceField_); input.ReadStringArray(tag, field_name, result.repeatedStringPieceField_);
break; break;
} }
case 98: { case 98: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedCordField_); input.ReadStringArray(tag, field_name, result.repeatedCordField_);
break; break;
} }
} }
@ -15105,46 +15105,46 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _testPackedTypesFieldNames; string[] field_names = _testPackedTypesFieldNames;
if (packedInt32_.Count > 0) { if (packedInt32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Int32, 90, field_names[6], packedInt32MemoizedSerializedSize, packedInt32_); output.WritePackedInt32Array(90, field_names[6], packedInt32MemoizedSerializedSize, packedInt32_);
} }
if (packedInt64_.Count > 0) { if (packedInt64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Int64, 91, field_names[7], packedInt64MemoizedSerializedSize, packedInt64_); output.WritePackedInt64Array(91, field_names[7], packedInt64MemoizedSerializedSize, packedInt64_);
} }
if (packedUint32_.Count > 0) { if (packedUint32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.UInt32, 92, field_names[12], packedUint32MemoizedSerializedSize, packedUint32_); output.WritePackedUInt32Array(92, field_names[12], packedUint32MemoizedSerializedSize, packedUint32_);
} }
if (packedUint64_.Count > 0) { if (packedUint64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.UInt64, 93, field_names[13], packedUint64MemoizedSerializedSize, packedUint64_); output.WritePackedUInt64Array(93, field_names[13], packedUint64MemoizedSerializedSize, packedUint64_);
} }
if (packedSint32_.Count > 0) { if (packedSint32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SInt32, 94, field_names[10], packedSint32MemoizedSerializedSize, packedSint32_); output.WritePackedSInt32Array(94, field_names[10], packedSint32MemoizedSerializedSize, packedSint32_);
} }
if (packedSint64_.Count > 0) { if (packedSint64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SInt64, 95, field_names[11], packedSint64MemoizedSerializedSize, packedSint64_); output.WritePackedSInt64Array(95, field_names[11], packedSint64MemoizedSerializedSize, packedSint64_);
} }
if (packedFixed32_.Count > 0) { if (packedFixed32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Fixed32, 96, field_names[3], packedFixed32MemoizedSerializedSize, packedFixed32_); output.WritePackedFixed32Array(96, field_names[3], packedFixed32MemoizedSerializedSize, packedFixed32_);
} }
if (packedFixed64_.Count > 0) { if (packedFixed64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Fixed64, 97, field_names[4], packedFixed64MemoizedSerializedSize, packedFixed64_); output.WritePackedFixed64Array(97, field_names[4], packedFixed64MemoizedSerializedSize, packedFixed64_);
} }
if (packedSfixed32_.Count > 0) { if (packedSfixed32_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SFixed32, 98, field_names[8], packedSfixed32MemoizedSerializedSize, packedSfixed32_); output.WritePackedSFixed32Array(98, field_names[8], packedSfixed32MemoizedSerializedSize, packedSfixed32_);
} }
if (packedSfixed64_.Count > 0) { if (packedSfixed64_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SFixed64, 99, field_names[9], packedSfixed64MemoizedSerializedSize, packedSfixed64_); output.WritePackedSFixed64Array(99, field_names[9], packedSfixed64MemoizedSerializedSize, packedSfixed64_);
} }
if (packedFloat_.Count > 0) { if (packedFloat_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Float, 100, field_names[5], packedFloatMemoizedSerializedSize, packedFloat_); output.WritePackedFloatArray(100, field_names[5], packedFloatMemoizedSerializedSize, packedFloat_);
} }
if (packedDouble_.Count > 0) { if (packedDouble_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Double, 101, field_names[1], packedDoubleMemoizedSerializedSize, packedDouble_); output.WritePackedDoubleArray(101, field_names[1], packedDoubleMemoizedSerializedSize, packedDouble_);
} }
if (packedBool_.Count > 0) { if (packedBool_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Bool, 102, field_names[0], packedBoolMemoizedSerializedSize, packedBool_); output.WritePackedBoolArray(102, field_names[0], packedBoolMemoizedSerializedSize, packedBool_);
} }
if (packedEnum_.Count > 0) { if (packedEnum_.Count > 0) {
output.WritePackedArray(pbd::FieldType.Enum, 103, field_names[2], packedEnumMemoizedSerializedSize, packedEnum_); output.WritePackedEnumArray(103, field_names[2], packedEnumMemoizedSerializedSize, packedEnum_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -15492,67 +15492,67 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 722: case 722:
case 720: { case 720: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.packedInt32_); input.ReadInt32Array(tag, field_name, result.packedInt32_);
break; break;
} }
case 730: case 730:
case 728: { case 728: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.packedInt64_); input.ReadInt64Array(tag, field_name, result.packedInt64_);
break; break;
} }
case 738: case 738:
case 736: { case 736: {
input.ReadPrimitiveArray(pbd::FieldType.UInt32, tag, field_name, result.packedUint32_); input.ReadUInt32Array(tag, field_name, result.packedUint32_);
break; break;
} }
case 746: case 746:
case 744: { case 744: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.packedUint64_); input.ReadUInt64Array(tag, field_name, result.packedUint64_);
break; break;
} }
case 754: case 754:
case 752: { case 752: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.packedSint32_); input.ReadSInt32Array(tag, field_name, result.packedSint32_);
break; break;
} }
case 762: case 762:
case 760: { case 760: {
input.ReadPrimitiveArray(pbd::FieldType.SInt64, tag, field_name, result.packedSint64_); input.ReadSInt64Array(tag, field_name, result.packedSint64_);
break; break;
} }
case 770: case 770:
case 773: { case 773: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.packedFixed32_); input.ReadFixed32Array(tag, field_name, result.packedFixed32_);
break; break;
} }
case 778: case 778:
case 777: { case 777: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.packedFixed64_); input.ReadFixed64Array(tag, field_name, result.packedFixed64_);
break; break;
} }
case 786: case 786:
case 789: { case 789: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed32, tag, field_name, result.packedSfixed32_); input.ReadSFixed32Array(tag, field_name, result.packedSfixed32_);
break; break;
} }
case 794: case 794:
case 793: { case 793: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed64, tag, field_name, result.packedSfixed64_); input.ReadSFixed64Array(tag, field_name, result.packedSfixed64_);
break; break;
} }
case 802: case 802:
case 805: { case 805: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.packedFloat_); input.ReadFloatArray(tag, field_name, result.packedFloat_);
break; break;
} }
case 810: case 810:
case 809: { case 809: {
input.ReadPrimitiveArray(pbd::FieldType.Double, tag, field_name, result.packedDouble_); input.ReadDoubleArray(tag, field_name, result.packedDouble_);
break; break;
} }
case 818: case 818:
case 816: { case 816: {
input.ReadPrimitiveArray(pbd::FieldType.Bool, tag, field_name, result.packedBool_); input.ReadBoolArray(tag, field_name, result.packedBool_);
break; break;
} }
case 826: case 826:
@ -16181,46 +16181,46 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _testUnpackedTypesFieldNames; string[] field_names = _testUnpackedTypesFieldNames;
if (unpackedInt32_.Count > 0) { if (unpackedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 90, field_names[6], unpackedInt32_); output.WriteInt32Array(90, field_names[6], unpackedInt32_);
} }
if (unpackedInt64_.Count > 0) { if (unpackedInt64_.Count > 0) {
output.WriteArray(pbd::FieldType.Int64, 91, field_names[7], unpackedInt64_); output.WriteInt64Array(91, field_names[7], unpackedInt64_);
} }
if (unpackedUint32_.Count > 0) { if (unpackedUint32_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt32, 92, field_names[12], unpackedUint32_); output.WriteUInt32Array(92, field_names[12], unpackedUint32_);
} }
if (unpackedUint64_.Count > 0) { if (unpackedUint64_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt64, 93, field_names[13], unpackedUint64_); output.WriteUInt64Array(93, field_names[13], unpackedUint64_);
} }
if (unpackedSint32_.Count > 0) { if (unpackedSint32_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt32, 94, field_names[10], unpackedSint32_); output.WriteSInt32Array(94, field_names[10], unpackedSint32_);
} }
if (unpackedSint64_.Count > 0) { if (unpackedSint64_.Count > 0) {
output.WriteArray(pbd::FieldType.SInt64, 95, field_names[11], unpackedSint64_); output.WriteSInt64Array(95, field_names[11], unpackedSint64_);
} }
if (unpackedFixed32_.Count > 0) { if (unpackedFixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed32, 96, field_names[3], unpackedFixed32_); output.WriteFixed32Array(96, field_names[3], unpackedFixed32_);
} }
if (unpackedFixed64_.Count > 0) { if (unpackedFixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed64, 97, field_names[4], unpackedFixed64_); output.WriteFixed64Array(97, field_names[4], unpackedFixed64_);
} }
if (unpackedSfixed32_.Count > 0) { if (unpackedSfixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed32, 98, field_names[8], unpackedSfixed32_); output.WriteSFixed32Array(98, field_names[8], unpackedSfixed32_);
} }
if (unpackedSfixed64_.Count > 0) { if (unpackedSfixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.SFixed64, 99, field_names[9], unpackedSfixed64_); output.WriteSFixed64Array(99, field_names[9], unpackedSfixed64_);
} }
if (unpackedFloat_.Count > 0) { if (unpackedFloat_.Count > 0) {
output.WriteArray(pbd::FieldType.Float, 100, field_names[5], unpackedFloat_); output.WriteFloatArray(100, field_names[5], unpackedFloat_);
} }
if (unpackedDouble_.Count > 0) { if (unpackedDouble_.Count > 0) {
output.WriteArray(pbd::FieldType.Double, 101, field_names[1], unpackedDouble_); output.WriteDoubleArray(101, field_names[1], unpackedDouble_);
} }
if (unpackedBool_.Count > 0) { if (unpackedBool_.Count > 0) {
output.WriteArray(pbd::FieldType.Bool, 102, field_names[0], unpackedBool_); output.WriteBoolArray(102, field_names[0], unpackedBool_);
} }
if (unpackedEnum_.Count > 0) { if (unpackedEnum_.Count > 0) {
output.WriteArray(pbd::FieldType.Enum, 103, field_names[2], unpackedEnum_); output.WriteEnumArray(103, field_names[2], unpackedEnum_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -16527,67 +16527,67 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 722: case 722:
case 720: { case 720: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.unpackedInt32_); input.ReadInt32Array(tag, field_name, result.unpackedInt32_);
break; break;
} }
case 730: case 730:
case 728: { case 728: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.unpackedInt64_); input.ReadInt64Array(tag, field_name, result.unpackedInt64_);
break; break;
} }
case 738: case 738:
case 736: { case 736: {
input.ReadPrimitiveArray(pbd::FieldType.UInt32, tag, field_name, result.unpackedUint32_); input.ReadUInt32Array(tag, field_name, result.unpackedUint32_);
break; break;
} }
case 746: case 746:
case 744: { case 744: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.unpackedUint64_); input.ReadUInt64Array(tag, field_name, result.unpackedUint64_);
break; break;
} }
case 754: case 754:
case 752: { case 752: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.unpackedSint32_); input.ReadSInt32Array(tag, field_name, result.unpackedSint32_);
break; break;
} }
case 762: case 762:
case 760: { case 760: {
input.ReadPrimitiveArray(pbd::FieldType.SInt64, tag, field_name, result.unpackedSint64_); input.ReadSInt64Array(tag, field_name, result.unpackedSint64_);
break; break;
} }
case 770: case 770:
case 773: { case 773: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.unpackedFixed32_); input.ReadFixed32Array(tag, field_name, result.unpackedFixed32_);
break; break;
} }
case 778: case 778:
case 777: { case 777: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.unpackedFixed64_); input.ReadFixed64Array(tag, field_name, result.unpackedFixed64_);
break; break;
} }
case 786: case 786:
case 789: { case 789: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed32, tag, field_name, result.unpackedSfixed32_); input.ReadSFixed32Array(tag, field_name, result.unpackedSfixed32_);
break; break;
} }
case 794: case 794:
case 793: { case 793: {
input.ReadPrimitiveArray(pbd::FieldType.SFixed64, tag, field_name, result.unpackedSfixed64_); input.ReadSFixed64Array(tag, field_name, result.unpackedSfixed64_);
break; break;
} }
case 802: case 802:
case 805: { case 805: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.unpackedFloat_); input.ReadFloatArray(tag, field_name, result.unpackedFloat_);
break; break;
} }
case 810: case 810:
case 809: { case 809: {
input.ReadPrimitiveArray(pbd::FieldType.Double, tag, field_name, result.unpackedDouble_); input.ReadDoubleArray(tag, field_name, result.unpackedDouble_);
break; break;
} }
case 818: case 818:
case 816: { case 816: {
input.ReadPrimitiveArray(pbd::FieldType.Bool, tag, field_name, result.unpackedBool_); input.ReadBoolArray(tag, field_name, result.unpackedBool_);
break; break;
} }
case 826: case 826:
@ -17792,10 +17792,10 @@ namespace Google.ProtocolBuffers.TestProtos {
output.WriteMessage(2004, field_names[1], DynamicMessageExtension); output.WriteMessage(2004, field_names[1], DynamicMessageExtension);
} }
if (repeatedExtension_.Count > 0) { if (repeatedExtension_.Count > 0) {
output.WriteArray(pbd::FieldType.String, 2005, field_names[5], repeatedExtension_); output.WriteStringArray(2005, field_names[5], repeatedExtension_);
} }
if (packedExtension_.Count > 0) { if (packedExtension_.Count > 0) {
output.WritePackedArray(pbd::FieldType.SInt32, 2006, field_names[4], packedExtensionMemoizedSerializedSize, packedExtension_); output.WritePackedSInt32Array(2006, field_names[4], packedExtensionMemoizedSerializedSize, packedExtension_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -18048,12 +18048,12 @@ namespace Google.ProtocolBuffers.TestProtos {
break; break;
} }
case 16042: { case 16042: {
input.ReadPrimitiveArray(pbd::FieldType.String, tag, field_name, result.repeatedExtension_); input.ReadStringArray(tag, field_name, result.repeatedExtension_);
break; break;
} }
case 16050: case 16050:
case 16048: { case 16048: {
input.ReadPrimitiveArray(pbd::FieldType.SInt32, tag, field_name, result.packedExtension_); input.ReadSInt32Array(tag, field_name, result.packedExtension_);
break; break;
} }
} }
@ -18368,22 +18368,22 @@ namespace Google.ProtocolBuffers.TestProtos {
int size = SerializedSize; int size = SerializedSize;
string[] field_names = _testRepeatedScalarDifferentTagSizesFieldNames; string[] field_names = _testRepeatedScalarDifferentTagSizesFieldNames;
if (repeatedFixed32_.Count > 0) { if (repeatedFixed32_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed32, 12, field_names[0], repeatedFixed32_); output.WriteFixed32Array(12, field_names[0], repeatedFixed32_);
} }
if (repeatedInt32_.Count > 0) { if (repeatedInt32_.Count > 0) {
output.WriteArray(pbd::FieldType.Int32, 13, field_names[3], repeatedInt32_); output.WriteInt32Array(13, field_names[3], repeatedInt32_);
} }
if (repeatedFixed64_.Count > 0) { if (repeatedFixed64_.Count > 0) {
output.WriteArray(pbd::FieldType.Fixed64, 2046, field_names[1], repeatedFixed64_); output.WriteFixed64Array(2046, field_names[1], repeatedFixed64_);
} }
if (repeatedInt64_.Count > 0) { if (repeatedInt64_.Count > 0) {
output.WriteArray(pbd::FieldType.Int64, 2047, field_names[4], repeatedInt64_); output.WriteInt64Array(2047, field_names[4], repeatedInt64_);
} }
if (repeatedFloat_.Count > 0) { if (repeatedFloat_.Count > 0) {
output.WriteArray(pbd::FieldType.Float, 262142, field_names[2], repeatedFloat_); output.WriteFloatArray(262142, field_names[2], repeatedFloat_);
} }
if (repeatedUint64_.Count > 0) { if (repeatedUint64_.Count > 0) {
output.WriteArray(pbd::FieldType.UInt64, 262143, field_names[5], repeatedUint64_); output.WriteUInt64Array(262143, field_names[5], repeatedUint64_);
} }
UnknownFields.WriteTo(output); UnknownFields.WriteTo(output);
} }
@ -18600,32 +18600,32 @@ namespace Google.ProtocolBuffers.TestProtos {
} }
case 98: case 98:
case 101: { case 101: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed32, tag, field_name, result.repeatedFixed32_); input.ReadFixed32Array(tag, field_name, result.repeatedFixed32_);
break; break;
} }
case 106: case 106:
case 104: { case 104: {
input.ReadPrimitiveArray(pbd::FieldType.Int32, tag, field_name, result.repeatedInt32_); input.ReadInt32Array(tag, field_name, result.repeatedInt32_);
break; break;
} }
case 16370: case 16370:
case 16369: { case 16369: {
input.ReadPrimitiveArray(pbd::FieldType.Fixed64, tag, field_name, result.repeatedFixed64_); input.ReadFixed64Array(tag, field_name, result.repeatedFixed64_);
break; break;
} }
case 16378: case 16378:
case 16376: { case 16376: {
input.ReadPrimitiveArray(pbd::FieldType.Int64, tag, field_name, result.repeatedInt64_); input.ReadInt64Array(tag, field_name, result.repeatedInt64_);
break; break;
} }
case 2097138: case 2097138:
case 2097141: { case 2097141: {
input.ReadPrimitiveArray(pbd::FieldType.Float, tag, field_name, result.repeatedFloat_); input.ReadFloatArray(tag, field_name, result.repeatedFloat_);
break; break;
} }
case 2097146: case 2097146:
case 2097144: { case 2097144: {
input.ReadPrimitiveArray(pbd::FieldType.UInt64, tag, field_name, result.repeatedUint64_); input.ReadUInt64Array(tag, field_name, result.repeatedUint64_);
break; break;
} }
} }

Write Preview
Loading…
Cancel
Save