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

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

Browse Source 
Prod code works, but some tests are broken. Obviously those need fixing, then more tests,
and review benchmarks.
pull/560/head
Jon Skeet 10 years ago
parent 241e17ba78
commit f2a27cc2c7
12 changed files with 693 additions and 1920 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 30
      csharp/src/AddressBook/Addressbook.cs
  2. 89
      csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs
  3. 1038
      csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs
  4. 288
      csharp/src/ProtocolBuffers/CodedInputStream.cs
  5. 325
      csharp/src/ProtocolBuffers/CodedOutputStream.cs
  6. 10
      csharp/src/ProtocolBuffers/Collections/MapField.cs
  7. 182
      csharp/src/ProtocolBuffers/Collections/RepeatedField.cs
  8. 466
      csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
  9. 56
      csharp/src/ProtocolBuffers/FieldCodec.cs
  10. 47
      src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
  11. 19
      src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
  12. 63
      src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc

30
csharp/src/AddressBook/Addressbook.cs
Unescape View File

@ -131,6 +131,8 @@ namespace Google.Protobuf.Examples.AddressBook {
}
public const int PhoneFieldNumber = 4;
private static readonly pb::FieldCodec<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber> _repeated_phone_codec
= pb::FieldCodec.ForMessage(34, global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber> phone_ = new pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber>();
public pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber> Phone {
get { return phone_; }
@ -176,9 +178,7 @@ namespace Google.Protobuf.Examples.AddressBook {
output.WriteRawTag(26);
output.WriteString(Email);
}
if (phone_.Count > 0) {
output.WriteMessageArray(4, phone_);
}
phone_.WriteTo(output, _repeated_phone_codec);
}
public int CalculateSize() {
@ -192,12 +192,7 @@ namespace Google.Protobuf.Examples.AddressBook {
if (Email.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Email);
}
if (phone_.Count > 0) {
foreach (global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber element in phone_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * phone_.Count;
}
size += phone_.CalculateSize(_repeated_phone_codec);
return size;
}
@ -241,7 +236,7 @@ namespace Google.Protobuf.Examples.AddressBook {
break;
}
case 34: {
input.ReadMessageArray(phone_, global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneNumber.Parser);
phone_.AddEntriesFrom(input, _repeated_phone_codec);
break;
}
}
@ -437,6 +432,8 @@ namespace Google.Protobuf.Examples.AddressBook {
}
public const int PersonFieldNumber = 1;
private static readonly pb::FieldCodec<global::Google.Protobuf.Examples.AddressBook.Person> _repeated_person_codec
= pb::FieldCodec.ForMessage(10, global::Google.Protobuf.Examples.AddressBook.Person.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person> person_ = new pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person>();
public pbc::RepeatedField<global::Google.Protobuf.Examples.AddressBook.Person> Person {
get { return person_; }
@ -464,19 +461,12 @@ namespace Google.Protobuf.Examples.AddressBook {
}
public void WriteTo(pb::CodedOutputStream output) {
if (person_.Count > 0) {
output.WriteMessageArray(1, person_);
}
person_.WriteTo(output, _repeated_person_codec);
}
public int CalculateSize() {
int size = 0;
if (person_.Count > 0) {
foreach (global::Google.Protobuf.Examples.AddressBook.Person element in person_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * person_.Count;
}
size += person_.CalculateSize(_repeated_person_codec);
return size;
}
@ -499,7 +489,7 @@ namespace Google.Protobuf.Examples.AddressBook {
}
break;
case 10: {
input.ReadMessageArray(person_, global::Google.Protobuf.Examples.AddressBook.Person.Parser);
person_.AddEntriesFrom(input, _repeated_person_codec);
break;
}
}

89
csharp/src/ProtocolBuffers.Test/TestProtos/UnittestIssues.cs
Unescape View File

@ -422,13 +422,15 @@ namespace UnitTest.Issues.TestProtos {
}
public const int ValuesFieldNumber = 2;
private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> values_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>();
private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.NegativeEnum> _repeated_values_codec
= pb::FieldCodec.ForEnum(16, x => (int) x, x => (global::UnitTest.Issues.TestProtos.NegativeEnum) x);private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> values_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>();
public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> Values {
get { return values_; }
}
public const int PackedValuesFieldNumber = 3;
private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> packedValues_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>();
private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.NegativeEnum> _repeated_packedValues_codec
= pb::FieldCodec.ForEnum(26, x => (int) x, x => (global::UnitTest.Issues.TestProtos.NegativeEnum) x);private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> packedValues_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>();
public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> PackedValues {
get { return packedValues_; }
}
@ -463,13 +465,8 @@ namespace UnitTest.Issues.TestProtos {
output.WriteRawTag(8);
output.WriteEnum((int) Value);
}
if (values_.Count > 0) {
output.WriteEnumArray(2, values_);
}
if (packedValues_.Count > 0) {
output.WriteRawTag(26);
output.WritePackedEnumArray(packedValues_);
}
values_.WriteTo(output, _repeated_values_codec);
packedValues_.WriteTo(output, _repeated_packedValues_codec);
}
public int CalculateSize() {
@ -477,22 +474,8 @@ namespace UnitTest.Issues.TestProtos {
if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO) {
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Value);
}
if (values_.Count > 0) {
int dataSize = 0;
foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in values_) {
dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
}
size += dataSize;
size += 1 * values_.Count;
}
if (packedValues_.Count > 0) {
int dataSize = 0;
foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in packedValues_) {
dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
}
size += dataSize;
size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
}
size += values_.CalculateSize(_repeated_values_codec);
size += packedValues_.CalculateSize(_repeated_packedValues_codec);
return size;
}
@ -524,12 +507,12 @@ namespace UnitTest.Issues.TestProtos {
}
case 18:
case 16: {
input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(values_);
values_.AddEntriesFrom(input, _repeated_values_codec);
break;
}
case 26:
case 24: {
input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(packedValues_);
packedValues_.AddEntriesFrom(input, _repeated_packedValues_codec);
break;
}
}
@ -678,6 +661,8 @@ namespace UnitTest.Issues.TestProtos {
}
public const int PrimitiveArrayFieldNumber = 2;
private static readonly pb::FieldCodec<int> _repeated_primitiveArray_codec
= pb::FieldCodec.ForInt32(18);
private readonly pbc::RepeatedField<int> primitiveArray_ = new pbc::RepeatedField<int>();
[global::System.ObsoleteAttribute()]
public pbc::RepeatedField<int> PrimitiveArray {
@ -696,6 +681,8 @@ namespace UnitTest.Issues.TestProtos {
}
public const int MessageArrayFieldNumber = 4;
private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.DeprecatedChild> _repeated_messageArray_codec
= pb::FieldCodec.ForMessage(34, global::UnitTest.Issues.TestProtos.DeprecatedChild.Parser);
private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild> messageArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild>();
[global::System.ObsoleteAttribute()]
public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild> MessageArray {
@ -714,7 +701,8 @@ namespace UnitTest.Issues.TestProtos {
}
public const int EnumArrayFieldNumber = 6;
private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> enumArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum>();
private static readonly pb::FieldCodec<global::UnitTest.Issues.TestProtos.DeprecatedEnum> _repeated_enumArray_codec
= pb::FieldCodec.ForEnum(50, x => (int) x, x => (global::UnitTest.Issues.TestProtos.DeprecatedEnum) x);private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> enumArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum>();
[global::System.ObsoleteAttribute()]
public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> EnumArray {
get { return enumArray_; }
@ -756,25 +744,17 @@ namespace UnitTest.Issues.TestProtos {
output.WriteRawTag(8);
output.WriteInt32(PrimitiveValue);
}
if (primitiveArray_.Count > 0) {
output.WriteRawTag(18);
output.WritePackedInt32Array(primitiveArray_);
}
primitiveArray_.WriteTo(output, _repeated_primitiveArray_codec);
if (messageValue_ != null) {
output.WriteRawTag(26);
output.WriteMessage(MessageValue);
}
if (messageArray_.Count > 0) {
output.WriteMessageArray(4, messageArray_);
}
messageArray_.WriteTo(output, _repeated_messageArray_codec);
if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) {
output.WriteRawTag(40);
output.WriteEnum((int) EnumValue);
}
if (enumArray_.Count > 0) {
output.WriteRawTag(50);
output.WritePackedEnumArray(enumArray_);
}
enumArray_.WriteTo(output, _repeated_enumArray_codec);
}
public int CalculateSize() {
@ -782,34 +762,15 @@ namespace UnitTest.Issues.TestProtos {
if (PrimitiveValue != 0) {
size += 1 + pb::CodedOutputStream.ComputeInt32Size(PrimitiveValue);
}
if (primitiveArray_.Count > 0) {
int dataSize = 0;
foreach (int element in primitiveArray_) {
dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
}
size += dataSize;
size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
}
size += primitiveArray_.CalculateSize(_repeated_primitiveArray_codec);
if (messageValue_ != null) {
size += 1 + pb::CodedOutputStream.ComputeMessageSize(MessageValue);
}
if (messageArray_.Count > 0) {
foreach (global::UnitTest.Issues.TestProtos.DeprecatedChild element in messageArray_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * messageArray_.Count;
}
size += messageArray_.CalculateSize(_repeated_messageArray_codec);
if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) {
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) EnumValue);
}
if (enumArray_.Count > 0) {
int dataSize = 0;
foreach (global::UnitTest.Issues.TestProtos.DeprecatedEnum element in enumArray_) {
dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);
}
size += dataSize;
size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);
}
size += enumArray_.CalculateSize(_repeated_enumArray_codec);
return size;
}
@ -851,7 +812,7 @@ namespace UnitTest.Issues.TestProtos {
}
case 18:
case 16: {
input.ReadInt32Array(primitiveArray_);
primitiveArray_.AddEntriesFrom(input, _repeated_primitiveArray_codec);
break;
}
case 26: {
@ -862,7 +823,7 @@ namespace UnitTest.Issues.TestProtos {
break;
}
case 34: {
input.ReadMessageArray(messageArray_, global::UnitTest.Issues.TestProtos.DeprecatedChild.Parser);
messageArray_.AddEntriesFrom(input, _repeated_messageArray_codec);
break;
}
case 40: {
@ -871,7 +832,7 @@ namespace UnitTest.Issues.TestProtos {
}
case 50:
case 48: {
input.ReadEnumArray<global::UnitTest.Issues.TestProtos.DeprecatedEnum>(enumArray_);
enumArray_.AddEntriesFrom(input, _repeated_enumArray_codec);
break;
}
}

1038
csharp/src/ProtocolBuffers.Test/TestProtos/UnittestProto3.cs
View File

File diff suppressed because it is too large Load Diff

288
csharp/src/ProtocolBuffers/CodedInputStream.cs
Unescape View File

@ -172,6 +172,12 @@ namespace Google.Protobuf
}
}
/// <summary>
/// Returns the last tag read, or 0 if no tags have been read or we've read beyond
/// the end of the stream.
/// </summary>
internal uint LastTag { get { return lastTag; } }
#region Validation
/// <summary>
@ -435,26 +441,6 @@ namespace Google.Protobuf
return DecodeZigZag64(ReadRawVarint64());
}
private bool BeginArray(uint fieldTag, out bool isPacked, out int oldLimit)
{
isPacked = WireFormat.GetTagWireType(fieldTag) == WireFormat.WireType.LengthDelimited;
if (isPacked)
{
int length = (int) (ReadRawVarint32() & int.MaxValue);
if (length > 0)
{
oldLimit = PushLimit(length);
return true;
}
oldLimit = -1;
return false; //packed but empty
}
oldLimit = -1;
return true;
}
/// <summary>
/// Peeks at the next tag in the stream. If it matches <paramref name="tag"/>,
/// the tag is consumed and the method returns <c>true</c>; otherwise, the
@ -474,268 +460,6 @@ namespace Google.Protobuf
return false;
}
/// <summary>
/// Returns true if the next tag is also part of the same array, which may or may not be packed.
/// </summary>
private bool ContinueArray(uint currentTag, bool packed, int oldLimit)
{
if (packed)
{
if (ReachedLimit)
{
PopLimit(oldLimit);
return false;
}
return true;
}
return MaybeConsumeTag(currentTag);
}
/// <summary>
/// Reads a string array.
/// </summary>
/// <remarks>The stream is assumed to be positioned after a tag indicating the field
/// repeated string value. A string is read, and then if the next tag is the same,
/// the process is repeated, until the next tag is a different one.</remarks>
/// <param name="list"></param>
public void ReadStringArray(ICollection<string> list)
{
uint fieldTag = lastTag;
do
{
list.Add(ReadString());
} while (MaybeConsumeTag(fieldTag));
}
public void ReadBytesArray(ICollection<ByteString> list)
{
uint fieldTag = lastTag;
do
{
list.Add(ReadBytes());
} while (MaybeConsumeTag(fieldTag));
}
public void ReadBoolArray(ICollection<bool> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadBool());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadInt32Array(ICollection<int> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadInt32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadSInt32Array(ICollection<int> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadSInt32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadUInt32Array(ICollection<uint> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadUInt32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadFixed32Array(ICollection<uint> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadFixed32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadSFixed32Array(ICollection<int> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadSFixed32());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadInt64Array(ICollection<long> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadInt64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadSInt64Array(ICollection<long> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadSInt64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadUInt64Array(ICollection<ulong> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadUInt64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadFixed64Array(ICollection<ulong> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadFixed64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadSFixed64Array(ICollection<long> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadSFixed64());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadDoubleArray(ICollection<double> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadDouble());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadFloatArray(ICollection<float> list)
{
uint fieldTag = lastTag;
bool isPacked;
int holdLimit;
if (BeginArray(fieldTag, out isPacked, out holdLimit))
{
do
{
list.Add(ReadFloat());
} while (ContinueArray(fieldTag, isPacked, holdLimit));
}
}
public void ReadEnumArray<T>(RepeatedField<T> list)
where T : struct, IComparable, IFormattable
{
uint fieldTag = lastTag;
WireFormat.WireType wformat = WireFormat.GetTagWireType(fieldTag);
// 2.3 allows packed form even if the field is not declared packed.
if (wformat == WireFormat.WireType.LengthDelimited)
{
int length = (int) (ReadRawVarint32() & int.MaxValue);
int limit = PushLimit(length);
while (!ReachedLimit)
{
// Ghastly hack, but it works...
list.AddInt32(ReadEnum());
}
PopLimit(limit);
}
else
{
do
{
list.Add((T)(object) ReadEnum());
} while (MaybeConsumeTag(fieldTag));
}
}
public void ReadMessageArray<T>(ICollection<T> list, MessageParser<T> messageParser)
where T : IMessage<T>
{
uint fieldTag = lastTag;
do
{
T message = messageParser.CreateTemplate();
ReadMessage(message);
list.Add(message);
} while (MaybeConsumeTag(fieldTag));
}
#endregion
#region Underlying reading primitives

325
csharp/src/ProtocolBuffers/CodedOutputStream.cs
Unescape View File

@ -306,166 +306,6 @@ namespace Google.Protobuf
#endregion
#region Write array members, with fields.
public void WriteMessageArray<T>(int fieldNumber, RepeatedField<T> list)
where T : IMessage
{
foreach (T value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteMessage(value);
}
}
public void WriteStringArray(int fieldNumber, RepeatedField<string> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteString(value);
}
}
public void WriteBytesArray(int fieldNumber, RepeatedField<ByteString> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited);
WriteBytes(value);
}
}
public void WriteBoolArray(int fieldNumber, RepeatedField<bool> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteBool(value);
}
}
public void WriteInt32Array(int fieldNumber, RepeatedField<int> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteInt32(value);
}
}
public void WriteSInt32Array(int fieldNumber, RepeatedField<int> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteSInt32(value);
}
}
public void WriteUInt32Array(int fieldNumber, RepeatedField<uint> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteUInt32(value);
}
}
public void WriteFixed32Array(int fieldNumber, RepeatedField<uint> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
WriteFixed32(value);
}
}
public void WriteSFixed32Array(int fieldNumber, RepeatedField<int> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
WriteSFixed32(value);
}
}
public void WriteInt64Array(int fieldNumber, RepeatedField<long> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteInt64(value);
}
}
public void WriteSInt64Array(int fieldNumber, RepeatedField<long> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteSInt64(value);
}
}
public void WriteUInt64Array(int fieldNumber, RepeatedField<ulong> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteUInt64(value);
}
}
public void WriteFixed64Array(int fieldNumber, RepeatedField<ulong> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteFixed64(value);
}
}
public void WriteSFixed64Array(int fieldNumber, RepeatedField<long> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteSFixed64(value);
}
}
public void WriteDoubleArray(int fieldNumber, RepeatedField<double> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed64);
WriteDouble(value);
}
}
public void WriteFloatArray(int fieldNumber, RepeatedField<float> list)
{
foreach (var value in list)
{
WriteTag(fieldNumber, WireFormat.WireType.Fixed32);
WriteFloat(value);
}
}
public void WriteEnumArray<T>(int fieldNumber, RepeatedField<T> list)
where T : struct, IComparable, IFormattable
{
// Bit of a hack, to access the values as ints
var iterator = list.GetInt32Enumerator();
while (iterator.MoveNext())
{
WriteTag(fieldNumber, WireFormat.WireType.Varint);
WriteEnum(iterator.Current);
}
}
#endregion
#region Raw tag writing
/// <summary>
/// Encodes and writes a tag.
@ -534,171 +374,6 @@ namespace Google.Protobuf
}
#endregion
#region Write packed array members
// TODO(jonskeet): A lot of these are really inefficient, due to method group conversions. Fix!
// (Alternatively, add extension methods to RepeatedField, accepting the Write* methods via delegates too.)
public void WritePackedBoolArray(RepeatedField<bool> list)
{
uint size = (uint)list.Count;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteBool(value);
}
}
public void WritePackedInt32Array(RepeatedField<int> list)
{
uint size = list.CalculateSize(ComputeInt32Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteInt32(value);
}
}
public void WritePackedSInt32Array(RepeatedField<int> list)
{
uint size = list.CalculateSize(ComputeSInt32Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteSInt32(value);
}
}
public void WritePackedUInt32Array(RepeatedField<uint> list)
{
uint size = list.CalculateSize(ComputeUInt32Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteUInt32(value);
}
}
public void WritePackedFixed32Array(RepeatedField<uint> list)
{
uint size = (uint) list.Count * 4;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteFixed32(value);
}
}
public void WritePackedSFixed32Array(RepeatedField<int> list)
{
uint size = (uint) list.Count * 4;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteSFixed32(value);
}
}
public void WritePackedInt64Array(RepeatedField<long> list)
{
uint size = list.CalculateSize(ComputeInt64Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteInt64(value);
}
}
public void WritePackedSInt64Array(RepeatedField<long> list)
{
uint size = list.CalculateSize(ComputeSInt64Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteSInt64(value);
}
}
public void WritePackedUInt64Array(RepeatedField<ulong> list)
{
if (list.Count == 0)
{
return;
}
uint size = list.CalculateSize(ComputeUInt64Size);
WriteRawVarint32(size);
foreach (var value in list)
{
WriteUInt64(value);
}
}
public void WritePackedFixed64Array(RepeatedField<ulong> list)
{
uint size = (uint) list.Count * 8;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteFixed64(value);
}
}
public void WritePackedSFixed64Array(RepeatedField<long> list)
{
uint size = (uint) list.Count * 8;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteSFixed64(value);
}
}
public void WritePackedDoubleArray(RepeatedField<double> list)
{
uint size = (uint) list.Count * 8;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteDouble(value);
}
}
public void WritePackedFloatArray(RepeatedField<float> list)
{
if (list.Count == 0)
{
return;
}
uint size = (uint) list.Count * 4;
WriteRawVarint32(size);
foreach (var value in list)
{
WriteFloat(value);
}
}
public void WritePackedEnumArray<T>(RepeatedField<T> list)
where T : struct, IComparable, IFormattable
{
if (list.Count == 0)
{
return;
}
// Bit of a hack, to access the values as ints
var iterator = list.GetInt32Enumerator();
uint size = 0;
while (iterator.MoveNext())
{
size += (uint) ComputeEnumSize(iterator.Current);
}
iterator.Reset();
WriteRawVarint32(size);
while (iterator.MoveNext())
{
WriteEnum(iterator.Current);
}
}
#endregion
#region Underlying writing primitives
/// <summary>
/// Writes a 32 bit value as a varint. The fast route is taken when

10
csharp/src/ProtocolBuffers/Collections/MapField.cs
Unescape View File

@ -334,6 +334,10 @@ namespace Google.Protobuf.Collections
public int CalculateSize(Codec codec)
{
if (Count == 0)
{
return 0;
}
var message = new Codec.MessageAdapter(codec);
int size = 0;
foreach (var entry in list)
@ -419,13 +423,13 @@ namespace Google.Protobuf.Collections
public void WriteTo(CodedOutputStream output)
{
codec.keyCodec.Write(output, Key);
codec.valueCodec.Write(output, Value);
codec.keyCodec.WriteTagAndValue(output, Key);
codec.valueCodec.WriteTagAndValue(output, Value);
}
public int CalculateSize()
{
return codec.keyCodec.CalculateSize(Key) + codec.valueCodec.CalculateSize(Value);
return codec.keyCodec.CalculateSizeWithTag(Key) + codec.valueCodec.CalculateSizeWithTag(Value);
}
}
}

182
csharp/src/ProtocolBuffers/Collections/RepeatedField.cs
Unescape View File

@ -49,6 +49,112 @@ namespace Google.Protobuf.Collections
return clone;
}
public void AddEntriesFrom(CodedInputStream input, FieldCodec<T> codec)
{
uint tag = input.LastTag;
var reader = codec.ValueReader;
// Value types can be packed or not.
if (typeof(T).IsValueType && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited)
{
int length = (int)(input.ReadRawVarint32() & int.MaxValue);
if (length > 0)
{
int oldLimit = input.PushLimit(length);
while (!input.ReachedLimit)
{
Add(reader(input));
}
input.PopLimit(oldLimit);
}
// Empty packed field. Odd, but valid - just ignore.
}
else
{
// Not packed... (possibly not packable)
do
{
Add(reader(input));
} while (input.MaybeConsumeTag(tag));
}
}
public int CalculateSize(FieldCodec<T> codec)
{
if (count == 0)
{
return 0;
}
uint tag = codec.Tag;
if (typeof(T).IsValueType && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited)
{
int dataSize = CalculatePackedDataSize(codec);
return CodedOutputStream.ComputeRawVarint32Size(tag) +
CodedOutputStream.ComputeRawVarint32Size((uint)dataSize) +
dataSize;
}
else
{
var sizeCalculator = codec.ValueSizeCalculator;
int size = count * CodedOutputStream.ComputeRawVarint32Size(tag);
for (int i = 0; i < count; i++)
{
size += sizeCalculator(array[i]);
}
return size;
}
}
private int CalculatePackedDataSize(FieldCodec<T> codec)
{
int fixedSize = codec.FixedSize;
if (fixedSize == 0)
{
var calculator = codec.ValueSizeCalculator;
int tmp = 0;
for (int i = 0; i < count; i++)
{
tmp += calculator(array[i]);
}
return tmp;
}
else
{
return fixedSize * Count;
}
}
public void WriteTo(CodedOutputStream output, FieldCodec<T> codec)
{
// TODO: Assert that T is a value type, and that codec.Tag is packed?
if (count == 0)
{
return;
}
var writer = codec.ValueWriter;
var tag = codec.Tag;
if (typeof(T).IsValueType && WireFormat.GetTagWireType(tag) == WireFormat.WireType.LengthDelimited)
{
// Packed primitive type
uint size = (uint)CalculatePackedDataSize(codec);
output.WriteTag(tag);
output.WriteRawVarint32(size);
for (int i = 0; i < count; i++)
{
writer(output, array[i]);
}
}
else
{
// Not packed: a simple tag/value pair for each value.
// Can't use codec.WriteTagAndValue, as that omits default values.
for (int i = 0; i < count; i++)
{
output.WriteTag(tag);
writer(output, array[i]);
}
}
}
public bool IsFrozen { get { return frozen; } }
public void Freeze()
@ -87,18 +193,6 @@ namespace Google.Protobuf.Collections
array[count++] = item;
}
/// <summary>
/// Hack to allow us to add enums easily... will only work with int-based types.
/// </summary>
/// <param name="readEnum"></param>
internal void AddInt32(int item)
{
this.CheckMutable();
EnsureSize(count + 1);
int[] castArray = (int[]) (object) array;
castArray[count++] = item;
}
public void Clear()
{
this.CheckMutable();
@ -180,16 +274,7 @@ namespace Google.Protobuf.Collections
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
/// <summary>
/// Returns an enumerator of the values in this list as integers.
/// Used for enum types.
/// </summary>
internal Int32Enumerator GetInt32Enumerator()
{
return new Int32Enumerator((int[])(object)array, count);
}
}
public override int GetHashCode()
{
@ -297,17 +382,7 @@ namespace Google.Protobuf.Collections
array[index] = value;
}
}
internal uint CalculateSize(Func<T, int> sizeComputer)
{
int size = 0;
for (int i = 0; i < count; i++)
{
size += sizeComputer(array[i]);
}
return (uint)size;
}
public struct Enumerator : IEnumerator<T>
{
private int index;
@ -355,46 +430,5 @@ namespace Google.Protobuf.Collections
{
}
}
internal struct Int32Enumerator : IEnumerator<int>
{
private int index;
private readonly int[] array;
private readonly int count;
public Int32Enumerator(int[] array, int count)
{
this.array = array;
this.index = -1;
this.count = count;
}
public bool MoveNext()
{
if (index + 1 >= count)
{
return false;
}
index++;
return true;
}
public void Reset()
{
index = -1;
}
// No guard here, as we're only going to use this internally...
public int Current { get { return array[index]; } }
object IEnumerator.Current
{
get { return Current; }
}
public void Dispose()
{
}
}
}
}

466
csharp/src/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs
Unescape View File

@ -314,6 +314,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int FileFieldNumber = 1;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto> _repeated_file_codec
= pb::FieldCodec.ForMessage(10, global::Google.Protobuf.DescriptorProtos.FileDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto> file_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FileDescriptorProto> File {
get { return file_; }
@ -341,19 +343,12 @@ namespace Google.Protobuf.DescriptorProtos {
}
public void WriteTo(pb::CodedOutputStream output) {
if (file_.Count > 0) {
output.WriteMessageArray(1, file_);
}
file_.WriteTo(output, _repeated_file_codec);
}
public int CalculateSize() {
int size = 0;
if (file_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.FileDescriptorProto element in file_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * file_.Count;
}
size += file_.CalculateSize(_repeated_file_codec);
return size;
}
@ -376,7 +371,7 @@ namespace Google.Protobuf.DescriptorProtos {
}
break;
case 10: {
input.ReadMessageArray(file_, global::Google.Protobuf.DescriptorProtos.FileDescriptorProto.Parser);
file_.AddEntriesFrom(input, _repeated_file_codec);
break;
}
}
@ -461,42 +456,56 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int DependencyFieldNumber = 3;
private static readonly pb::FieldCodec<string> _repeated_dependency_codec
= pb::FieldCodec.ForString(26);
private readonly pbc::RepeatedField<string> dependency_ = new pbc::RepeatedField<string>();
public pbc::RepeatedField<string> Dependency {
get { return dependency_; }
}
public const int PublicDependencyFieldNumber = 10;
private static readonly pb::FieldCodec<int> _repeated_publicDependency_codec
= pb::FieldCodec.ForInt32(80);
private readonly pbc::RepeatedField<int> publicDependency_ = new pbc::RepeatedField<int>();
public pbc::RepeatedField<int> PublicDependency {
get { return publicDependency_; }
}
public const int WeakDependencyFieldNumber = 11;
private static readonly pb::FieldCodec<int> _repeated_weakDependency_codec
= pb::FieldCodec.ForInt32(88);
private readonly pbc::RepeatedField<int> weakDependency_ = new pbc::RepeatedField<int>();
public pbc::RepeatedField<int> WeakDependency {
get { return weakDependency_; }
}
public const int MessageTypeFieldNumber = 4;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto> _repeated_messageType_codec
= pb::FieldCodec.ForMessage(34, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> messageType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> MessageType {
get { return messageType_; }
}
public const int EnumTypeFieldNumber = 5;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> _repeated_enumType_codec
= pb::FieldCodec.ForMessage(42, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> EnumType {
get { return enumType_; }
}
public const int ServiceFieldNumber = 6;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto> _repeated_service_codec
= pb::FieldCodec.ForMessage(50, global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto> service_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto> Service {
get { return service_; }
}
public const int ExtensionFieldNumber = 7;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> _repeated_extension_codec
= pb::FieldCodec.ForMessage(58, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> Extension {
get { return extension_; }
@ -584,21 +593,11 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(18);
output.WriteString(Package);
}
if (dependency_.Count > 0) {
output.WriteStringArray(3, dependency_);
}
if (messageType_.Count > 0) {
output.WriteMessageArray(4, messageType_);
}
if (enumType_.Count > 0) {
output.WriteMessageArray(5, enumType_);
}
if (service_.Count > 0) {
output.WriteMessageArray(6, service_);
}
if (extension_.Count > 0) {
output.WriteMessageArray(7, extension_);
}
dependency_.WriteTo(output, _repeated_dependency_codec);
messageType_.WriteTo(output, _repeated_messageType_codec);
enumType_.WriteTo(output, _repeated_enumType_codec);
service_.WriteTo(output, _repeated_service_codec);
extension_.WriteTo(output, _repeated_extension_codec);
if (options_ != null) {
output.WriteRawTag(66);
output.WriteMessage(Options);
@ -607,12 +606,8 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(74);
output.WriteMessage(SourceCodeInfo);
}
if (publicDependency_.Count > 0) {
output.WriteInt32Array(10, publicDependency_);
}
if (weakDependency_.Count > 0) {
output.WriteInt32Array(11, weakDependency_);
}
publicDependency_.WriteTo(output, _repeated_publicDependency_codec);
weakDependency_.WriteTo(output, _repeated_weakDependency_codec);
if (Syntax.Length != 0) {
output.WriteRawTag(98);
output.WriteString(Syntax);
@ -627,54 +622,13 @@ namespace Google.Protobuf.DescriptorProtos {
if (Package.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Package);
}
if (dependency_.Count > 0) {
int dataSize = 0;
foreach (string element in dependency_) {
dataSize += pb::CodedOutputStream.ComputeStringSize(element);
}
size += dataSize;
size += 1 * dependency_.Count;
}
if (publicDependency_.Count > 0) {
int dataSize = 0;
foreach (int element in publicDependency_) {
dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
}
size += dataSize;
size += 1 * publicDependency_.Count;
}
if (weakDependency_.Count > 0) {
int dataSize = 0;
foreach (int element in weakDependency_) {
dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
}
size += dataSize;
size += 1 * weakDependency_.Count;
}
if (messageType_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto element in messageType_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * messageType_.Count;
}
if (enumType_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto element in enumType_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * enumType_.Count;
}
if (service_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto element in service_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * service_.Count;
}
if (extension_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto element in extension_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * extension_.Count;
}
size += dependency_.CalculateSize(_repeated_dependency_codec);
size += publicDependency_.CalculateSize(_repeated_publicDependency_codec);
size += weakDependency_.CalculateSize(_repeated_weakDependency_codec);
size += messageType_.CalculateSize(_repeated_messageType_codec);
size += enumType_.CalculateSize(_repeated_enumType_codec);
size += service_.CalculateSize(_repeated_service_codec);
size += extension_.CalculateSize(_repeated_extension_codec);
if (options_ != null) {
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
}
@ -741,23 +695,23 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 26: {
input.ReadStringArray(dependency_);
dependency_.AddEntriesFrom(input, _repeated_dependency_codec);
break;
}
case 34: {
input.ReadMessageArray(messageType_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
messageType_.AddEntriesFrom(input, _repeated_messageType_codec);
break;
}
case 42: {
input.ReadMessageArray(enumType_, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
enumType_.AddEntriesFrom(input, _repeated_enumType_codec);
break;
}
case 50: {
input.ReadMessageArray(service_, global::Google.Protobuf.DescriptorProtos.ServiceDescriptorProto.Parser);
service_.AddEntriesFrom(input, _repeated_service_codec);
break;
}
case 58: {
input.ReadMessageArray(extension_, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
extension_.AddEntriesFrom(input, _repeated_extension_codec);
break;
}
case 66: {
@ -776,12 +730,12 @@ namespace Google.Protobuf.DescriptorProtos {
}
case 82:
case 80: {
input.ReadInt32Array(publicDependency_);
publicDependency_.AddEntriesFrom(input, _repeated_publicDependency_codec);
break;
}
case 90:
case 88: {
input.ReadInt32Array(weakDependency_);
weakDependency_.AddEntriesFrom(input, _repeated_weakDependency_codec);
break;
}
case 98: {
@ -858,36 +812,48 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int FieldFieldNumber = 2;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> _repeated_field_codec
= pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> field_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> Field {
get { return field_; }
}
public const int ExtensionFieldNumber = 6;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> _repeated_extension_codec
= pb::FieldCodec.ForMessage(50, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> extension_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto> Extension {
get { return extension_; }
}
public const int NestedTypeFieldNumber = 3;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto> _repeated_nestedType_codec
= pb::FieldCodec.ForMessage(26, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> nestedType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto> NestedType {
get { return nestedType_; }
}
public const int EnumTypeFieldNumber = 4;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> _repeated_enumType_codec
= pb::FieldCodec.ForMessage(34, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> enumType_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto> EnumType {
get { return enumType_; }
}
public const int ExtensionRangeFieldNumber = 5;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange> _repeated_extensionRange_codec
= pb::FieldCodec.ForMessage(42, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange> extensionRange_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange> ExtensionRange {
get { return extensionRange_; }
}
public const int OneofDeclFieldNumber = 8;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto> _repeated_oneofDecl_codec
= pb::FieldCodec.ForMessage(66, global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto> oneofDecl_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto> OneofDecl {
get { return oneofDecl_; }
@ -904,12 +870,16 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int ReservedRangeFieldNumber = 9;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange> _repeated_reservedRange_codec
= pb::FieldCodec.ForMessage(74, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange> reservedRange_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange> ReservedRange {
get { return reservedRange_; }
}
public const int ReservedNameFieldNumber = 10;
private static readonly pb::FieldCodec<string> _repeated_reservedName_codec
= pb::FieldCodec.ForString(82);
private readonly pbc::RepeatedField<string> reservedName_ = new pbc::RepeatedField<string>();
public pbc::RepeatedField<string> ReservedName {
get { return reservedName_; }
@ -959,34 +929,18 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(10);
output.WriteString(Name);
}
if (field_.Count > 0) {
output.WriteMessageArray(2, field_);
}
if (nestedType_.Count > 0) {
output.WriteMessageArray(3, nestedType_);
}
if (enumType_.Count > 0) {
output.WriteMessageArray(4, enumType_);
}
if (extensionRange_.Count > 0) {
output.WriteMessageArray(5, extensionRange_);
}
if (extension_.Count > 0) {
output.WriteMessageArray(6, extension_);
}
field_.WriteTo(output, _repeated_field_codec);
nestedType_.WriteTo(output, _repeated_nestedType_codec);
enumType_.WriteTo(output, _repeated_enumType_codec);
extensionRange_.WriteTo(output, _repeated_extensionRange_codec);
extension_.WriteTo(output, _repeated_extension_codec);
if (options_ != null) {
output.WriteRawTag(58);
output.WriteMessage(Options);
}
if (oneofDecl_.Count > 0) {
output.WriteMessageArray(8, oneofDecl_);
}
if (reservedRange_.Count > 0) {
output.WriteMessageArray(9, reservedRange_);
}
if (reservedName_.Count > 0) {
output.WriteStringArray(10, reservedName_);
}
oneofDecl_.WriteTo(output, _repeated_oneofDecl_codec);
reservedRange_.WriteTo(output, _repeated_reservedRange_codec);
reservedName_.WriteTo(output, _repeated_reservedName_codec);
}
public int CalculateSize() {
@ -994,59 +948,17 @@ namespace Google.Protobuf.DescriptorProtos {
if (Name.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
}
if (field_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto element in field_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * field_.Count;
}
if (extension_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto element in extension_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * extension_.Count;
}
if (nestedType_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto element in nestedType_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * nestedType_.Count;
}
if (enumType_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto element in enumType_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * enumType_.Count;
}
if (extensionRange_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange element in extensionRange_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * extensionRange_.Count;
}
if (oneofDecl_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto element in oneofDecl_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * oneofDecl_.Count;
}
size += field_.CalculateSize(_repeated_field_codec);
size += extension_.CalculateSize(_repeated_extension_codec);
size += nestedType_.CalculateSize(_repeated_nestedType_codec);
size += enumType_.CalculateSize(_repeated_enumType_codec);
size += extensionRange_.CalculateSize(_repeated_extensionRange_codec);
size += oneofDecl_.CalculateSize(_repeated_oneofDecl_codec);
if (options_ != null) {
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
}
if (reservedRange_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange element in reservedRange_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * reservedRange_.Count;
}
if (reservedName_.Count > 0) {
int dataSize = 0;
foreach (string element in reservedName_) {
dataSize += pb::CodedOutputStream.ComputeStringSize(element);
}
size += dataSize;
size += 1 * reservedName_.Count;
}
size += reservedRange_.CalculateSize(_repeated_reservedRange_codec);
size += reservedName_.CalculateSize(_repeated_reservedName_codec);
return size;
}
@ -1089,23 +1001,23 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 18: {
input.ReadMessageArray(field_, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
field_.AddEntriesFrom(input, _repeated_field_codec);
break;
}
case 26: {
input.ReadMessageArray(nestedType_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Parser);
nestedType_.AddEntriesFrom(input, _repeated_nestedType_codec);
break;
}
case 34: {
input.ReadMessageArray(enumType_, global::Google.Protobuf.DescriptorProtos.EnumDescriptorProto.Parser);
enumType_.AddEntriesFrom(input, _repeated_enumType_codec);
break;
}
case 42: {
input.ReadMessageArray(extensionRange_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Parser);
extensionRange_.AddEntriesFrom(input, _repeated_extensionRange_codec);
break;
}
case 50: {
input.ReadMessageArray(extension_, global::Google.Protobuf.DescriptorProtos.FieldDescriptorProto.Parser);
extension_.AddEntriesFrom(input, _repeated_extension_codec);
break;
}
case 58: {
@ -1116,15 +1028,15 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 66: {
input.ReadMessageArray(oneofDecl_, global::Google.Protobuf.DescriptorProtos.OneofDescriptorProto.Parser);
oneofDecl_.AddEntriesFrom(input, _repeated_oneofDecl_codec);
break;
}
case 74: {
input.ReadMessageArray(reservedRange_, global::Google.Protobuf.DescriptorProtos.DescriptorProto.Types.ReservedRange.Parser);
reservedRange_.AddEntriesFrom(input, _repeated_reservedRange_codec);
break;
}
case 82: {
input.ReadStringArray(reservedName_);
reservedName_.AddEntriesFrom(input, _repeated_reservedName_codec);
break;
}
}
@ -1943,6 +1855,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int ValueFieldNumber = 2;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto> _repeated_value_codec
= pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto> value_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto> Value {
get { return value_; }
@ -1988,9 +1902,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(10);
output.WriteString(Name);
}
if (value_.Count > 0) {
output.WriteMessageArray(2, value_);
}
value_.WriteTo(output, _repeated_value_codec);
if (options_ != null) {
output.WriteRawTag(26);
output.WriteMessage(Options);
@ -2002,12 +1914,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Name.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
}
if (value_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto element in value_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * value_.Count;
}
size += value_.CalculateSize(_repeated_value_codec);
if (options_ != null) {
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
}
@ -2046,7 +1953,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 18: {
input.ReadMessageArray(value_, global::Google.Protobuf.DescriptorProtos.EnumValueDescriptorProto.Parser);
value_.AddEntriesFrom(input, _repeated_value_codec);
break;
}
case 26: {
@ -2284,6 +2191,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int MethodFieldNumber = 2;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto> _repeated_method_codec
= pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto> method_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto> Method {
get { return method_; }
@ -2329,9 +2238,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(10);
output.WriteString(Name);
}
if (method_.Count > 0) {
output.WriteMessageArray(2, method_);
}
method_.WriteTo(output, _repeated_method_codec);
if (options_ != null) {
output.WriteRawTag(26);
output.WriteMessage(Options);
@ -2343,12 +2250,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Name.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
}
if (method_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto element in method_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * method_.Count;
}
size += method_.CalculateSize(_repeated_method_codec);
if (options_ != null) {
size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options);
}
@ -2387,7 +2289,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 18: {
input.ReadMessageArray(method_, global::Google.Protobuf.DescriptorProtos.MethodDescriptorProto.Parser);
method_.AddEntriesFrom(input, _repeated_method_codec);
break;
}
case 26: {
@ -2847,6 +2749,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
@ -2958,9 +2862,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(170, 2);
output.WriteString(CsharpNamespace);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
@ -3007,12 +2909,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (CsharpNamespace.Length != 0) {
size += 2 + pb::CodedOutputStream.ComputeStringSize(CsharpNamespace);
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
@ -3133,7 +3030,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
@ -3235,6 +3132,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
@ -3286,9 +3185,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(56);
output.WriteBool(MapEntry);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
@ -3305,12 +3202,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (MapEntry != false) {
size += 1 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
@ -3361,7 +3253,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
@ -3473,6 +3365,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
@ -3536,9 +3430,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(80);
output.WriteBool(Weak);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
@ -3561,12 +3453,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Weak != false) {
size += 1 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
@ -3631,7 +3518,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
@ -3717,6 +3604,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
@ -3756,9 +3645,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(24);
output.WriteBool(Deprecated);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
@ -3769,12 +3656,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Deprecated != false) {
size += 1 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
@ -3811,7 +3693,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
@ -3868,6 +3750,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
@ -3901,9 +3785,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(8);
output.WriteBool(Deprecated);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
@ -3911,12 +3793,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Deprecated != false) {
size += 1 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
@ -3946,7 +3823,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
@ -4003,6 +3880,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
@ -4036,9 +3915,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(136, 2);
output.WriteBool(Deprecated);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
@ -4046,12 +3923,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Deprecated != false) {
size += 2 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
@ -4081,7 +3953,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
@ -4138,6 +4010,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int UninterpretedOptionFieldNumber = 999;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> _repeated_uninterpretedOption_codec
= pb::FieldCodec.ForMessage(7994, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> uninterpretedOption_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption> UninterpretedOption {
get { return uninterpretedOption_; }
@ -4171,9 +4045,7 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(136, 2);
output.WriteBool(Deprecated);
}
if (uninterpretedOption_.Count > 0) {
output.WriteMessageArray(999, uninterpretedOption_);
}
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
}
public int CalculateSize() {
@ -4181,12 +4053,7 @@ namespace Google.Protobuf.DescriptorProtos {
if (Deprecated != false) {
size += 2 + 1;
}
if (uninterpretedOption_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption element in uninterpretedOption_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 2 * uninterpretedOption_.Count;
}
size += uninterpretedOption_.CalculateSize(_repeated_uninterpretedOption_codec);
return size;
}
@ -4216,7 +4083,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 7994: {
input.ReadMessageArray(uninterpretedOption_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Parser);
uninterpretedOption_.AddEntriesFrom(input, _repeated_uninterpretedOption_codec);
break;
}
}
@ -4268,6 +4135,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int NameFieldNumber = 2;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart> _repeated_name_codec
= pb::FieldCodec.ForMessage(18, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart> name_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart> Name {
get { return name_; }
@ -4367,9 +4236,7 @@ namespace Google.Protobuf.DescriptorProtos {
}
public void WriteTo(pb::CodedOutputStream output) {
if (name_.Count > 0) {
output.WriteMessageArray(2, name_);
}
name_.WriteTo(output, _repeated_name_codec);
if (IdentifierValue.Length != 0) {
output.WriteRawTag(26);
output.WriteString(IdentifierValue);
@ -4398,12 +4265,7 @@ namespace Google.Protobuf.DescriptorProtos {
public int CalculateSize() {
int size = 0;
if (name_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart element in name_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * name_.Count;
}
size += name_.CalculateSize(_repeated_name_codec);
if (IdentifierValue.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(IdentifierValue);
}
@ -4462,7 +4324,7 @@ namespace Google.Protobuf.DescriptorProtos {
}
break;
case 18: {
input.ReadMessageArray(name_, global::Google.Protobuf.DescriptorProtos.UninterpretedOption.Types.NamePart.Parser);
name_.AddEntriesFrom(input, _repeated_name_codec);
break;
}
case 26: {
@ -4676,6 +4538,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int LocationFieldNumber = 1;
private static readonly pb::FieldCodec<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location> _repeated_location_codec
= pb::FieldCodec.ForMessage(10, global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location.Parser);
private readonly pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location> location_ = new pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location>();
public pbc::RepeatedField<global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location> Location {
get { return location_; }
@ -4703,19 +4567,12 @@ namespace Google.Protobuf.DescriptorProtos {
}
public void WriteTo(pb::CodedOutputStream output) {
if (location_.Count > 0) {
output.WriteMessageArray(1, location_);
}
location_.WriteTo(output, _repeated_location_codec);
}
public int CalculateSize() {
int size = 0;
if (location_.Count > 0) {
foreach (global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location element in location_) {
size += pb::CodedOutputStream.ComputeMessageSize(element);
}
size += 1 * location_.Count;
}
size += location_.CalculateSize(_repeated_location_codec);
return size;
}
@ -4738,7 +4595,7 @@ namespace Google.Protobuf.DescriptorProtos {
}
break;
case 10: {
input.ReadMessageArray(location_, global::Google.Protobuf.DescriptorProtos.SourceCodeInfo.Types.Location.Parser);
location_.AddEntriesFrom(input, _repeated_location_codec);
break;
}
}
@ -4791,12 +4648,16 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int PathFieldNumber = 1;
private static readonly pb::FieldCodec<int> _repeated_path_codec
= pb::FieldCodec.ForInt32(10);
private readonly pbc::RepeatedField<int> path_ = new pbc::RepeatedField<int>();
public pbc::RepeatedField<int> Path {
get { return path_; }
}
public const int SpanFieldNumber = 2;
private static readonly pb::FieldCodec<int> _repeated_span_codec
= pb::FieldCodec.ForInt32(18);
private readonly pbc::RepeatedField<int> span_ = new pbc::RepeatedField<int>();
public pbc::RepeatedField<int> Span {
get { return span_; }
@ -4823,6 +4684,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public const int LeadingDetachedCommentsFieldNumber = 6;
private static readonly pb::FieldCodec<string> _repeated_leadingDetachedComments_codec
= pb::FieldCodec.ForString(50);
private readonly pbc::RepeatedField<string> leadingDetachedComments_ = new pbc::RepeatedField<string>();
public pbc::RepeatedField<string> LeadingDetachedComments {
get { return leadingDetachedComments_; }
@ -4858,14 +4721,8 @@ namespace Google.Protobuf.DescriptorProtos {
}
public void WriteTo(pb::CodedOutputStream output) {
if (path_.Count > 0) {
output.WriteRawTag(10);
output.WritePackedInt32Array(path_);
}
if (span_.Count > 0) {
output.WriteRawTag(18);
output.WritePackedInt32Array(span_);
}
path_.WriteTo(output, _repeated_path_codec);
span_.WriteTo(output, _repeated_span_codec);
if (LeadingComments.Length != 0) {
output.WriteRawTag(26);
output.WriteString(LeadingComments);
@ -4874,43 +4731,20 @@ namespace Google.Protobuf.DescriptorProtos {
output.WriteRawTag(34);
output.WriteString(TrailingComments);
}
if (leadingDetachedComments_.Count > 0) {
output.WriteStringArray(6, leadingDetachedComments_);
}
leadingDetachedComments_.WriteTo(output, _repeated_leadingDetachedComments_codec);
}
public int CalculateSize() {
int size = 0;
if (path_.Count > 0) {
int dataSize = 0;
foreach (int element in path_) {
dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
}
size += dataSize;
size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
}
if (span_.Count > 0) {
int dataSize = 0;
foreach (int element in span_) {
dataSize += pb::CodedOutputStream.ComputeInt32Size(element);
}
size += dataSize;
size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize);
}
size += path_.CalculateSize(_repeated_path_codec);
size += span_.CalculateSize(_repeated_span_codec);
if (LeadingComments.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(LeadingComments);
}
if (TrailingComments.Length != 0) {
size += 1 + pb::CodedOutputStream.ComputeStringSize(TrailingComments);
}
if (leadingDetachedComments_.Count > 0) {
int dataSize = 0;
foreach (string element in leadingDetachedComments_) {
dataSize += pb::CodedOutputStream.ComputeStringSize(element);
}
size += dataSize;
size += 1 * leadingDetachedComments_.Count;
}
size += leadingDetachedComments_.CalculateSize(_repeated_leadingDetachedComments_codec);
return size;
}
@ -4942,12 +4776,12 @@ namespace Google.Protobuf.DescriptorProtos {
break;
case 10:
case 8: {
input.ReadInt32Array(path_);
path_.AddEntriesFrom(input, _repeated_path_codec);
break;
}
case 18:
case 16: {
input.ReadInt32Array(span_);
span_.AddEntriesFrom(input, _repeated_span_codec);
break;
}
case 26: {
@ -4959,7 +4793,7 @@ namespace Google.Protobuf.DescriptorProtos {
break;
}
case 50: {
input.ReadStringArray(leadingDetachedComments_);
leadingDetachedComments_.AddEntriesFrom(input, _repeated_leadingDetachedComments_codec);
break;
}
}

56
csharp/src/ProtocolBuffers/FieldCodec.cs
Unescape View File

@ -145,28 +145,68 @@ namespace Google.Protobuf
private readonly Func<CodedInputStream, T> reader;
private readonly Action<CodedOutputStream, T> writer;
private readonly Func<T, int> sizeComputer;
private readonly Func<T, int> sizeCalculator;
private readonly uint tag;
private readonly int tagSize;
private readonly int fixedSize;
internal FieldCodec(
Func<CodedInputStream, T> reader,
Action<CodedOutputStream, T> writer,
Func<T, int> sizeComputer,
Func<T, int> sizeCalculator,
uint tag)
{
this.reader = reader;
this.writer = writer;
this.sizeComputer = sizeComputer;
this.sizeCalculator = sizeCalculator;
this.fixedSize = 0;
this.tag = tag;
tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
}
internal FieldCodec(
Func<CodedInputStream, T> reader,
Action<CodedOutputStream, T> writer,
int fixedSize,
uint tag)
{
this.reader = reader;
this.writer = writer;
this.sizeCalculator = _ => fixedSize;
this.fixedSize = fixedSize;
this.tag = tag;
tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
}
/// <summary>
/// Returns the size calculator for just a value.
/// </summary>
internal Func<T, int> ValueSizeCalculator { get { return sizeCalculator; } }
/// <summary>
/// Returns a delegate to write a value (unconditionally) to a coded output stream.
/// </summary>
internal Action<CodedOutputStream, T> ValueWriter { get { return writer; } }
/// <summary>
/// Returns a delegate to read a value from a coded input stream. It is assumed that
/// the stream is already positioned on the appropriate tag.
/// </summary>
internal Func<CodedInputStream, T> ValueReader { get { return reader; } }
/// <summary>
/// Returns the fixed size for an entry, or 0 if sizes vary.
/// </summary>
internal int FixedSize { get { return fixedSize; } }
public uint Tag { get { return tag; } }
public T DefaultValue { get { return Default; } }
public void Write(CodedOutputStream output, T value)
/// <summary>
/// Write a tag and the given value, *if* the value is not the default.
/// </summary>
public void WriteTagAndValue(CodedOutputStream output, T value)
{
if (!IsDefault(value))
{
@ -180,9 +220,13 @@ namespace Google.Protobuf
return reader(input);
}
public int CalculateSize(T value)
/// <summary>
/// Calculates the size required to write the given value, with a tag,
/// if the value is not the default.
/// </summary>
public int CalculateSizeWithTag(T value)
{
return IsDefault(value) ? 0 : sizeComputer(value) + CodedOutputStream.ComputeRawVarint32Size(tag);
return IsDefault(value) ? 0 : sizeCalculator(value) + tagSize;
}
}
}

47
src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
Unescape View File

@ -49,7 +49,6 @@ namespace csharp {
RepeatedEnumFieldGenerator::RepeatedEnumFieldGenerator(
const FieldDescriptor* descriptor, int fieldOrdinal)
: FieldGeneratorBase(descriptor, fieldOrdinal) {
variables_["packed"] = descriptor->is_packed() ? "Packed" : "";
}
RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {
@ -57,6 +56,10 @@ RepeatedEnumFieldGenerator::~RepeatedEnumFieldGenerator() {
}
void RepeatedEnumFieldGenerator::GenerateMembers(io::Printer* printer) {
printer->Print(
variables_,
"private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
" = pb::FieldCodec.ForEnum($tag$, x => (int) x, x => ($type_name$) x);");
printer->Print(variables_,
"private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
AddDeprecatedFlag(printer);
@ -76,53 +79,19 @@ void RepeatedEnumFieldGenerator::GenerateMergingCode(io::Printer* printer) {
void RepeatedEnumFieldGenerator::GenerateParsingCode(io::Printer* printer) {
printer->Print(
variables_,
"input.ReadEnumArray<$type_name$>($name$_);\n");
"$name$_.AddEntriesFrom(input, _repeated_$name$_codec);\n");
}
void RepeatedEnumFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n");
printer->Indent();
if (descriptor_->is_packed()) {
printer->Print(
variables_,
"output.WriteRawTag($tag_bytes$);\n"
"output.WritePackedEnumArray($name$_);\n");
} else {
printer->Print(
variables_,
"output.Write$capitalized_type_name$Array($number$, $name$_);\n");
}
printer->Outdent();
printer->Print("}\n");
"$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedEnumFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
// TODO(jonskeet): Move all this code into CodedOutputStream? It's a lot to repeat everywhere...
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n");
printer->Indent();
printer->Print("int dataSize = 0;\n");
void RepeatedEnumFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
printer->Print(
variables_,
"foreach ($type_name$ element in $name$_) {\n"
" dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);\n"
"}\n"
"size += dataSize;\n");
int tagSize = internal::WireFormat::TagSize(descriptor_->number(), descriptor_->type());
if (descriptor_->is_packed()) {
printer->Print(
"size += $tag_size$ + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);\n",
"tag_size", SimpleItoa(tagSize));
} else {
printer->Print(
"size += $tag_size$ * $name$_.Count;\n",
"tag_size", SimpleItoa(tagSize), "name", name());
}
printer->Outdent();
printer->Print("}\n");
"size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
}
void RepeatedEnumFieldGenerator::WriteHash(io::Printer* printer) {

19
src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
Unescape View File

@ -55,6 +55,10 @@ RepeatedMessageFieldGenerator::~RepeatedMessageFieldGenerator() {
}
void RepeatedMessageFieldGenerator::GenerateMembers(io::Printer* printer) {
printer->Print(
variables_,
"private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
" = pb::FieldCodec.ForMessage($tag$, $type_name$.Parser);\n");
printer->Print(
variables_,
"private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
@ -75,28 +79,19 @@ void RepeatedMessageFieldGenerator::GenerateMergingCode(io::Printer* printer) {
void RepeatedMessageFieldGenerator::GenerateParsingCode(io::Printer* printer) {
printer->Print(
variables_,
"input.ReadMessageArray($name$_, $type_name$.Parser);\n");
"$name$_.AddEntriesFrom(input, _repeated_$name$_codec);\n");
}
void RepeatedMessageFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
// TODO(jonskeet): Bake the foreach loop into the generated code? We lose the
// advantage of knowing the tag bytes this way :(
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n"
" output.WriteMessageArray($number$, $name$_);\n"
"}\n");
"$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedMessageFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n"
" foreach ($type_name$ element in $name$_) {\n"
" size += pb::CodedOutputStream.ComputeMessageSize(element);\n"
" }\n"
" size += $tag_size$ * $name$_.Count;\n"
"}\n");
"size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
}
void RepeatedMessageFieldGenerator::WriteHash(io::Printer* printer) {

63
src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
Unescape View File

@ -49,7 +49,6 @@ namespace csharp {
RepeatedPrimitiveFieldGenerator::RepeatedPrimitiveFieldGenerator(
const FieldDescriptor* descriptor, int fieldOrdinal)
: FieldGeneratorBase(descriptor, fieldOrdinal) {
variables_["packed"] = descriptor->is_packed() ? "Packed" : "";
}
RepeatedPrimitiveFieldGenerator::~RepeatedPrimitiveFieldGenerator() {
@ -57,6 +56,10 @@ RepeatedPrimitiveFieldGenerator::~RepeatedPrimitiveFieldGenerator() {
}
void RepeatedPrimitiveFieldGenerator::GenerateMembers(io::Printer* printer) {
printer->Print(
variables_,
"private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
" = pb::FieldCodec.For$capitalized_type_name$($tag$);\n");
printer->Print(variables_,
"private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
AddDeprecatedFlag(printer);
@ -74,63 +77,21 @@ void RepeatedPrimitiveFieldGenerator::GenerateMergingCode(io::Printer* printer)
}
void RepeatedPrimitiveFieldGenerator::GenerateParsingCode(io::Printer* printer) {
printer->Print(variables_,
"input.Read$capitalized_type_name$Array($name$_);\n");
printer->Print(
variables_,
"$name$_.AddEntriesFrom(input, _repeated_$name$_codec);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializationCode(
io::Printer* printer) {
void RepeatedPrimitiveFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n");
printer->Indent();
if (descriptor_->is_packed()) {
printer->Print(
variables_,
"output.WriteRawTag($tag_bytes$);\n"
"output.WritePacked$capitalized_type_name$Array($name$_);\n");
} else {
printer->Print(
variables_,
"output.Write$capitalized_type_name$Array($number$, $name$_);\n");
}
printer->Outdent();
printer->Print("}\n");
"$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializedSizeCode(
io::Printer* printer) {
// TODO(jonskeet): Do this in the runtime if possible. It's a pain, but it must be feasible...
void RepeatedPrimitiveFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
printer->Print(
"if ($name$_.Count > 0) {\n",
"name", name());
printer->Indent();
printer->Print("int dataSize = 0;\n");
int fixedSize = GetFixedSize(descriptor_->type());
if (fixedSize == -1) {
printer->Print(
variables_,
"foreach ($type_name$ element in $name$_) {\n"
" dataSize += pb::CodedOutputStream.Compute$capitalized_type_name$Size(element);\n"
"}\n");
} else {
printer->Print(
"dataSize = $size$ * $name$_.Count;\n",
"size", SimpleItoa(fixedSize), "name", name());
}
printer->Print("size += dataSize;\n");
int tagSize = internal::WireFormat::TagSize(descriptor_->number(), descriptor_->type());
if (descriptor_->is_packed()) {
printer->Print(
"size += $tag_size$ + pb::CodedOutputStream.ComputeInt32Size(dataSize);\n",
"tag_size", SimpleItoa(tagSize));
} else {
printer->Print(
"size += $tag_size$ * $name$_.Count;\n",
"tag_size", SimpleItoa(tagSize), "name", name());
}
printer->Outdent();
printer->Print("}\n");
variables_,
"size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
}
void RepeatedPrimitiveFieldGenerator::WriteHash(io::Printer* printer) {

Write Preview
Loading…
Cancel
Save