organicmaps/protobuf
13
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity Actions

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.
This commit is contained in:
Jon Skeet 2015-06-26 17:37:14 +01:00
parent 241e17ba78
commit f2a27cc2c7
12 changed files with 695 additions and 1922 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
csharp/src/AddressBook/Addressbook.cs
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
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
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
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
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
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
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
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
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...
void RepeatedEnumFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
printer->Print(
variables_,
"if ($name$_.Count > 0) {\n");
printer->Indent();
printer->Print("int dataSize = 0;\n");
printer->Print(
variables_,
"foreach ($type_name$ element in $name$_) {\n"
" dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element);\n"
"}\n"
"size += dataSize;\n");
int tagSize = internal::WireFormat::TagSize(descriptor_->number(), descriptor_->type());
if (descriptor_->is_packed()) {
printer->Print(
"size += $tag_size$ + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize);\n",
"tag_size", SimpleItoa(tagSize));
} else {
printer->Print(
"size += $tag_size$ * $name$_.Count;\n",
"tag_size", SimpleItoa(tagSize), "name", name());
}
printer->Outdent();
printer->Print("}\n");
"size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
}
void RepeatedEnumFieldGenerator::WriteHash(io::Printer* printer) {

19
src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
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) {

67
src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
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");
}
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$_.AddEntriesFrom(input, _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::GenerateSerializationCode(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_,
"$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
printer->Print(
variables_,
"size += $name$_.CalculateSize(_repeated_$name$_codec);\n");
}
void RepeatedPrimitiveFieldGenerator::WriteHash(io::Printer* printer) {