diff --git a/Makefile.am b/Makefile.am
index 46d44d959984..323dc129dedf 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -96,11 +96,14 @@ csharp_EXTRA_DIST= \
csharp/src/Google.Protobuf.Benchmarks/Program.cs \
csharp/src/Google.Protobuf.Benchmarks/wrapper_benchmark_messages.proto \
csharp/src/Google.Protobuf.Benchmarks/WrapperBenchmarkMessages.cs \
+ csharp/src/Google.Protobuf.Benchmarks/WriteMessagesBenchmark.cs \
+ csharp/src/Google.Protobuf.Benchmarks/WriteRawPrimitivesBenchmark.cs \
csharp/src/Google.Protobuf.Conformance/Conformance.cs \
csharp/src/Google.Protobuf.Conformance/Google.Protobuf.Conformance.csproj \
csharp/src/Google.Protobuf.Conformance/Program.cs \
csharp/src/Google.Protobuf.JsonDump/Google.Protobuf.JsonDump.csproj \
csharp/src/Google.Protobuf.JsonDump/Program.cs \
+ csharp/src/Google.Protobuf.Test/Buffers/ArrayBufferWriter.cs \
csharp/src/Google.Protobuf.Test/ByteStringTest.cs \
csharp/src/Google.Protobuf.Test/CodedInputStreamExtensions.cs \
csharp/src/Google.Protobuf.Test/CodedInputStreamTest.cs \
@@ -259,6 +262,11 @@ csharp_EXTRA_DIST= \
csharp/src/Google.Protobuf/WellKnownTypes/Wrappers.cs \
csharp/src/Google.Protobuf/WellKnownTypes/WrappersPartial.cs \
csharp/src/Google.Protobuf/WireFormat.cs \
+ csharp/src/Google.Protobuf/WritingPrimitivesMessages.cs \
+ csharp/src/Google.Protobuf/WritingPrimitives.cs \
+ csharp/src/Google.Protobuf/WriterInternalState.cs \
+ csharp/src/Google.Protobuf/WriteContext.cs \
+ csharp/src/Google.Protobuf/WriteBufferHelper.cs \
csharp/src/Google.Protobuf/UnknownField.cs \
csharp/src/Google.Protobuf/UnknownFieldSet.cs
diff --git a/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/CodedOutputStreamTest.cs b/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/CodedOutputStreamTest.cs
index f25e14e96836..e9b4ea8cf0f3 100644
--- a/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/CodedOutputStreamTest.cs
+++ b/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/CodedOutputStreamTest.cs
@@ -211,35 +211,35 @@ public void WriteWholeMessage_VaryingBlockSizes()
[Test]
public void EncodeZigZag32()
{
- Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag32(0));
- Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag32(-1));
- Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag32(1));
- Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag32(-2));
- Assert.AreEqual(0x7FFFFFFEu, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF));
- Assert.AreEqual(0x7FFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0xC0000000)));
- Assert.AreEqual(0xFFFFFFFEu, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF));
- Assert.AreEqual(0xFFFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0x80000000)));
+ Assert.AreEqual(0u, WritingPrimitives.EncodeZigZag32(0));
+ Assert.AreEqual(1u, WritingPrimitives.EncodeZigZag32(-1));
+ Assert.AreEqual(2u, WritingPrimitives.EncodeZigZag32(1));
+ Assert.AreEqual(3u, WritingPrimitives.EncodeZigZag32(-2));
+ Assert.AreEqual(0x7FFFFFFEu, WritingPrimitives.EncodeZigZag32(0x3FFFFFFF));
+ Assert.AreEqual(0x7FFFFFFFu, WritingPrimitives.EncodeZigZag32(unchecked((int) 0xC0000000)));
+ Assert.AreEqual(0xFFFFFFFEu, WritingPrimitives.EncodeZigZag32(0x7FFFFFFF));
+ Assert.AreEqual(0xFFFFFFFFu, WritingPrimitives.EncodeZigZag32(unchecked((int) 0x80000000)));
}
[Test]
public void EncodeZigZag64()
{
- Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag64(0));
- Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag64(-1));
- Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag64(1));
- Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag64(-2));
+ Assert.AreEqual(0u, WritingPrimitives.EncodeZigZag64(0));
+ Assert.AreEqual(1u, WritingPrimitives.EncodeZigZag64(-1));
+ Assert.AreEqual(2u, WritingPrimitives.EncodeZigZag64(1));
+ Assert.AreEqual(3u, WritingPrimitives.EncodeZigZag64(-2));
Assert.AreEqual(0x000000007FFFFFFEuL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000003FFFFFFFUL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0x000000003FFFFFFFUL)));
Assert.AreEqual(0x000000007FFFFFFFuL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFFC0000000UL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0xFFFFFFFFC0000000UL)));
Assert.AreEqual(0x00000000FFFFFFFEuL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000007FFFFFFFUL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0x000000007FFFFFFFUL)));
Assert.AreEqual(0x00000000FFFFFFFFuL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFF80000000UL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0xFFFFFFFF80000000UL)));
Assert.AreEqual(0xFFFFFFFFFFFFFFFEL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0x7FFFFFFFFFFFFFFFUL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0x7FFFFFFFFFFFFFFFUL)));
Assert.AreEqual(0xFFFFFFFFFFFFFFFFL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0x8000000000000000UL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0x8000000000000000UL)));
}
[Test]
@@ -247,26 +247,26 @@ public void RoundTripZigZag32()
{
// Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1)
// were chosen semi-randomly via keyboard bashing.
- Assert.AreEqual(0, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0)));
- Assert.AreEqual(1, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1)));
- Assert.AreEqual(-1, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1)));
- Assert.AreEqual(14927, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927)));
- Assert.AreEqual(-3612, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612)));
+ Assert.AreEqual(0, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(0)));
+ Assert.AreEqual(1, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(1)));
+ Assert.AreEqual(-1, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(-1)));
+ Assert.AreEqual(14927, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(14927)));
+ Assert.AreEqual(-3612, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(-3612)));
}
[Test]
public void RoundTripZigZag64()
{
- Assert.AreEqual(0, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0)));
- Assert.AreEqual(1, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1)));
- Assert.AreEqual(-1, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1)));
- Assert.AreEqual(14927, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927)));
- Assert.AreEqual(-3612, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612)));
+ Assert.AreEqual(0, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(0)));
+ Assert.AreEqual(1, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(1)));
+ Assert.AreEqual(-1, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(-1)));
+ Assert.AreEqual(14927, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(14927)));
+ Assert.AreEqual(-3612, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(-3612)));
Assert.AreEqual(856912304801416L,
- ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L)));
+ ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(856912304801416L)));
Assert.AreEqual(-75123905439571256L,
- ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L)));
+ ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(-75123905439571256L)));
}
[Test]
@@ -395,7 +395,7 @@ public void Dispose_DisposesUnderlyingStream()
Assert.IsTrue(memoryStream.CanWrite);
using (var cos = new CodedOutputStream(memoryStream))
{
- cos.WriteRawByte(0);
+ cos.WriteRawBytes(new byte[] {0});
Assert.AreEqual(0, memoryStream.Position); // Not flushed yet
}
Assert.AreEqual(1, memoryStream.ToArray().Length); // Flushed data from CodedOutputStream to MemoryStream
@@ -409,7 +409,7 @@ public void Dispose_WithLeaveOpen()
Assert.IsTrue(memoryStream.CanWrite);
using (var cos = new CodedOutputStream(memoryStream, true))
{
- cos.WriteRawByte(0);
+ cos.WriteRawBytes(new byte[] {0});
Assert.AreEqual(0, memoryStream.Position); // Not flushed yet
}
Assert.AreEqual(1, memoryStream.Position); // Flushed data from CodedOutputStream to MemoryStream
diff --git a/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/FieldCodecTest.cs b/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/FieldCodecTest.cs
index a5825a070801..18e876721797 100644
--- a/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/FieldCodecTest.cs
+++ b/csharp/compatibility_tests/v3.0.0/src/Google.Protobuf.Test/FieldCodecTest.cs
@@ -124,7 +124,16 @@ public void TestRoundTripRaw()
{
var stream = new MemoryStream();
var codedOutput = new CodedOutputStream(stream);
- codec.ValueWriter(codedOutput, sampleValue);
+ WriteContext.Initialize(codedOutput, out WriteContext ctx);
+ try
+ {
+ // only write the value using the codec
+ codec.ValueWriter(ref ctx, sampleValue);
+ }
+ finally
+ {
+ ctx.CopyStateTo(codedOutput);
+ }
codedOutput.Flush();
stream.Position = 0;
var codedInput = new CodedInputStream(stream);
@@ -172,7 +181,16 @@ public void TestDefaultValue()
if (codec.DefaultValue != null) // This part isn't appropriate for message types.
{
codedOutput = new CodedOutputStream(stream);
- codec.ValueWriter(codedOutput, codec.DefaultValue);
+ WriteContext.Initialize(codedOutput, out WriteContext ctx);
+ try
+ {
+ // only write the value using the codec
+ codec.ValueWriter(ref ctx, codec.DefaultValue);
+ }
+ finally
+ {
+ ctx.CopyStateTo(codedOutput);
+ }
codedOutput.Flush();
Assert.AreNotEqual(0, stream.Position);
Assert.AreEqual(stream.Position, codec.ValueSizeCalculator(codec.DefaultValue));
diff --git a/csharp/src/AddressBook/Addressbook.cs b/csharp/src/AddressBook/Addressbook.cs
index 1b1c1b6c1f55..042f69ee60b8 100644
--- a/csharp/src/AddressBook/Addressbook.cs
+++ b/csharp/src/AddressBook/Addressbook.cs
@@ -190,6 +190,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -210,8 +213,35 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (Id != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Id);
+ }
+ if (Email.Length != 0) {
+ output.WriteRawTag(26);
+ output.WriteString(Email);
+ }
+ phones_.WriteTo(ref output, _repeated_phones_codec);
+ if (lastUpdated_ != null) {
+ output.WriteRawTag(42);
+ output.WriteMessage(LastUpdated);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -441,6 +471,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Number.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Number);
@@ -452,8 +485,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Number.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Number);
+ }
+ if (Type != global::Google.Protobuf.Examples.AddressBook.Person.Types.PhoneType.Mobile) {
+ output.WriteRawTag(16);
+ output.WriteEnum((int) Type);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -621,12 +672,26 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
people_.WriteTo(output, _repeated_people_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ people_.WriteTo(ref output, _repeated_people_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf.Benchmarks/BenchmarkMessage1Proto3.cs b/csharp/src/Google.Protobuf.Benchmarks/BenchmarkMessage1Proto3.cs
index 6a213346a664..027da02a10b5 100644
--- a/csharp/src/Google.Protobuf.Benchmarks/BenchmarkMessage1Proto3.cs
+++ b/csharp/src/Google.Protobuf.Benchmarks/BenchmarkMessage1Proto3.cs
@@ -706,6 +706,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Field1.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Field1);
@@ -870,7 +873,178 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Field1.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Field1);
+ }
+ if (Field2 != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Field2);
+ }
+ if (Field3 != 0) {
+ output.WriteRawTag(24);
+ output.WriteInt32(Field3);
+ }
+ if (Field4.Length != 0) {
+ output.WriteRawTag(34);
+ output.WriteString(Field4);
+ }
+ field5_.WriteTo(ref output, _repeated_field5_codec);
+ if (Field6 != 0) {
+ output.WriteRawTag(48);
+ output.WriteInt32(Field6);
+ }
+ if (Field7.Length != 0) {
+ output.WriteRawTag(58);
+ output.WriteString(Field7);
+ }
+ if (Field9.Length != 0) {
+ output.WriteRawTag(74);
+ output.WriteString(Field9);
+ }
+ if (Field12 != false) {
+ output.WriteRawTag(96);
+ output.WriteBool(Field12);
+ }
+ if (Field13 != false) {
+ output.WriteRawTag(104);
+ output.WriteBool(Field13);
+ }
+ if (Field14 != false) {
+ output.WriteRawTag(112);
+ output.WriteBool(Field14);
+ }
+ if (field15_ != null) {
+ output.WriteRawTag(122);
+ output.WriteMessage(Field15);
+ }
+ if (Field16 != 0) {
+ output.WriteRawTag(128, 1);
+ output.WriteInt32(Field16);
+ }
+ if (Field17 != false) {
+ output.WriteRawTag(136, 1);
+ output.WriteBool(Field17);
+ }
+ if (Field18.Length != 0) {
+ output.WriteRawTag(146, 1);
+ output.WriteString(Field18);
+ }
+ if (Field22 != 0L) {
+ output.WriteRawTag(176, 1);
+ output.WriteInt64(Field22);
+ }
+ if (Field23 != 0) {
+ output.WriteRawTag(184, 1);
+ output.WriteInt32(Field23);
+ }
+ if (Field24 != false) {
+ output.WriteRawTag(192, 1);
+ output.WriteBool(Field24);
+ }
+ if (Field25 != 0) {
+ output.WriteRawTag(200, 1);
+ output.WriteInt32(Field25);
+ }
+ if (Field29 != 0) {
+ output.WriteRawTag(232, 1);
+ output.WriteInt32(Field29);
+ }
+ if (Field30 != false) {
+ output.WriteRawTag(240, 1);
+ output.WriteBool(Field30);
+ }
+ if (Field59 != false) {
+ output.WriteRawTag(216, 3);
+ output.WriteBool(Field59);
+ }
+ if (Field60 != 0) {
+ output.WriteRawTag(224, 3);
+ output.WriteInt32(Field60);
+ }
+ if (Field67 != 0) {
+ output.WriteRawTag(152, 4);
+ output.WriteInt32(Field67);
+ }
+ if (Field68 != 0) {
+ output.WriteRawTag(160, 4);
+ output.WriteInt32(Field68);
+ }
+ if (Field78 != false) {
+ output.WriteRawTag(240, 4);
+ output.WriteBool(Field78);
+ }
+ if (Field80 != false) {
+ output.WriteRawTag(128, 5);
+ output.WriteBool(Field80);
+ }
+ if (Field81 != false) {
+ output.WriteRawTag(136, 5);
+ output.WriteBool(Field81);
+ }
+ if (Field100 != 0) {
+ output.WriteRawTag(160, 6);
+ output.WriteInt32(Field100);
+ }
+ if (Field101 != 0) {
+ output.WriteRawTag(168, 6);
+ output.WriteInt32(Field101);
+ }
+ if (Field102.Length != 0) {
+ output.WriteRawTag(178, 6);
+ output.WriteString(Field102);
+ }
+ if (Field103.Length != 0) {
+ output.WriteRawTag(186, 6);
+ output.WriteString(Field103);
+ }
+ if (Field104 != 0) {
+ output.WriteRawTag(192, 6);
+ output.WriteInt32(Field104);
+ }
+ if (Field128 != 0) {
+ output.WriteRawTag(128, 8);
+ output.WriteInt32(Field128);
+ }
+ if (Field129.Length != 0) {
+ output.WriteRawTag(138, 8);
+ output.WriteString(Field129);
+ }
+ if (Field130 != 0) {
+ output.WriteRawTag(144, 8);
+ output.WriteInt32(Field130);
+ }
+ if (Field131 != 0) {
+ output.WriteRawTag(152, 8);
+ output.WriteInt32(Field131);
+ }
+ if (Field150 != 0) {
+ output.WriteRawTag(176, 9);
+ output.WriteInt32(Field150);
+ }
+ if (Field271 != 0) {
+ output.WriteRawTag(248, 16);
+ output.WriteInt32(Field271);
+ }
+ if (Field272 != 0) {
+ output.WriteRawTag(128, 17);
+ output.WriteInt32(Field272);
+ }
+ if (Field280 != 0) {
+ output.WriteRawTag(192, 17);
+ output.WriteInt32(Field280);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1851,6 +2025,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Field1 != 0) {
output.WriteRawTag(8);
output.WriteInt32(Field1);
@@ -1934,7 +2111,97 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Field1 != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Field1);
+ }
+ if (Field2 != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Field2);
+ }
+ if (Field3 != 0) {
+ output.WriteRawTag(24);
+ output.WriteInt32(Field3);
+ }
+ if (Field12 != false) {
+ output.WriteRawTag(96);
+ output.WriteBool(Field12);
+ }
+ if (Field13 != 0L) {
+ output.WriteRawTag(104);
+ output.WriteInt64(Field13);
+ }
+ if (Field14 != 0L) {
+ output.WriteRawTag(112);
+ output.WriteInt64(Field14);
+ }
+ if (Field15.Length != 0) {
+ output.WriteRawTag(122);
+ output.WriteString(Field15);
+ }
+ if (Field16 != 0) {
+ output.WriteRawTag(128, 1);
+ output.WriteInt32(Field16);
+ }
+ if (Field19 != 0) {
+ output.WriteRawTag(152, 1);
+ output.WriteInt32(Field19);
+ }
+ if (Field20 != false) {
+ output.WriteRawTag(160, 1);
+ output.WriteBool(Field20);
+ }
+ if (Field21 != 0UL) {
+ output.WriteRawTag(169, 1);
+ output.WriteFixed64(Field21);
+ }
+ if (Field22 != 0) {
+ output.WriteRawTag(176, 1);
+ output.WriteInt32(Field22);
+ }
+ if (Field23 != false) {
+ output.WriteRawTag(184, 1);
+ output.WriteBool(Field23);
+ }
+ if (Field28 != false) {
+ output.WriteRawTag(224, 1);
+ output.WriteBool(Field28);
+ }
+ if (Field203 != 0) {
+ output.WriteRawTag(221, 12);
+ output.WriteFixed32(Field203);
+ }
+ if (Field204 != 0) {
+ output.WriteRawTag(224, 12);
+ output.WriteInt32(Field204);
+ }
+ if (Field205.Length != 0) {
+ output.WriteRawTag(234, 12);
+ output.WriteString(Field205);
+ }
+ if (Field206 != false) {
+ output.WriteRawTag(240, 12);
+ output.WriteBool(Field206);
+ }
+ if (Field207 != 0UL) {
+ output.WriteRawTag(248, 12);
+ output.WriteUInt64(Field207);
+ }
+ if (Field300 != 0UL) {
+ output.WriteRawTag(224, 18);
+ output.WriteUInt64(Field300);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Benchmarks/Benchmarks.cs b/csharp/src/Google.Protobuf.Benchmarks/Benchmarks.cs
index ce2248aed6b5..e2578f367fd2 100644
--- a/csharp/src/Google.Protobuf.Benchmarks/Benchmarks.cs
+++ b/csharp/src/Google.Protobuf.Benchmarks/Benchmarks.cs
@@ -176,6 +176,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -188,7 +191,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (MessageName.Length != 0) {
+ output.WriteRawTag(18);
+ output.WriteString(MessageName);
+ }
+ payload_.WriteTo(ref output, _repeated_payload_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Benchmarks/ParseMessagesBenchmark.cs b/csharp/src/Google.Protobuf.Benchmarks/ParseMessagesBenchmark.cs
index 92c3dbe5f02d..8e6710b7089c 100644
--- a/csharp/src/Google.Protobuf.Benchmarks/ParseMessagesBenchmark.cs
+++ b/csharp/src/Google.Protobuf.Benchmarks/ParseMessagesBenchmark.cs
@@ -151,7 +151,7 @@ public void RepeatedFieldMessage_ParseDelimitedMessagesFromReadOnlySequence(int
repeatedFieldTest.ParseDelimitedMessagesFromReadOnlySequence(messageCount);
}
- private static ManyWrapperFieldsMessage CreateManyWrapperFieldsMessage()
+ public static ManyWrapperFieldsMessage CreateManyWrapperFieldsMessage()
{
// Example data match data of an internal benchmarks
return new ManyWrapperFieldsMessage()
@@ -168,7 +168,7 @@ private static ManyWrapperFieldsMessage CreateManyWrapperFieldsMessage()
};
}
- private static ManyPrimitiveFieldsMessage CreateManyPrimitiveFieldsMessage()
+ public static ManyPrimitiveFieldsMessage CreateManyPrimitiveFieldsMessage()
{
// Example data match data of an internal benchmarks
return new ManyPrimitiveFieldsMessage()
@@ -185,7 +185,7 @@ private static ManyPrimitiveFieldsMessage CreateManyPrimitiveFieldsMessage()
};
}
- private static GoogleMessage1 CreateRepeatedFieldMessage()
+ public static GoogleMessage1 CreateRepeatedFieldMessage()
{
// Message with a repeated fixed length item collection
var message = new GoogleMessage1();
diff --git a/csharp/src/Google.Protobuf.Benchmarks/ParseRawPrimitivesBenchmark.cs b/csharp/src/Google.Protobuf.Benchmarks/ParseRawPrimitivesBenchmark.cs
index 863e74dc49d6..2f226a323cd4 100644
--- a/csharp/src/Google.Protobuf.Benchmarks/ParseRawPrimitivesBenchmark.cs
+++ b/csharp/src/Google.Protobuf.Benchmarks/ParseRawPrimitivesBenchmark.cs
@@ -337,7 +337,7 @@ private static byte[] CreateBufferWithRandomVarints(Random random, int valueCoun
CodedOutputStream cos = new CodedOutputStream(ms);
for (int i = 0; i < valueCount + paddingValueCount; i++)
{
- cos.WriteUInt64(RandomUnsignedVarint(random, encodedSize));
+ cos.WriteUInt64(RandomUnsignedVarint(random, encodedSize, false));
}
cos.Flush();
var buffer = ms.ToArray();
@@ -386,11 +386,11 @@ private static byte[] CreateBufferWithRandomData(Random random, int valueCount,
///
/// Generate a random value that will take exactly "encodedSize" bytes when varint-encoded.
///
- private static ulong RandomUnsignedVarint(Random random, int encodedSize)
+ public static ulong RandomUnsignedVarint(Random random, int encodedSize, bool fitsIn32Bits)
{
Span randomBytesBuffer = stackalloc byte[8];
- if (encodedSize < 1 || encodedSize > 10)
+ if (encodedSize < 1 || encodedSize > 10 || (fitsIn32Bits && encodedSize > 5))
{
throw new ArgumentException("Illegal encodedSize value requested", nameof(encodedSize));
}
@@ -406,6 +406,12 @@ private static ulong RandomUnsignedVarint(Random random, int encodedSize)
ulong bitmask = encodedSize < 10 ? ((1UL << (encodedSize * bitsPerByte)) - 1) : ulong.MaxValue;
result = randomValue & bitmask;
+ if (fitsIn32Bits)
+ {
+ // make sure the resulting value is representable by a uint.
+ result &= uint.MaxValue;
+ }
+
if (encodedSize == 10)
{
// for 10-byte values the highest bit always needs to be set (7*9=63)
@@ -443,7 +449,7 @@ private static byte[] CreateBufferWithStrings(int valueCount, int encodedSize, i
return buffer;
}
- private static string CreateStringWithEncodedSize(int encodedSize)
+ public static string CreateStringWithEncodedSize(int encodedSize)
{
var str = new string('a', encodedSize);
while (CodedOutputStream.ComputeStringSize(str) > encodedSize)
@@ -457,5 +463,34 @@ private static string CreateStringWithEncodedSize(int encodedSize)
}
return str;
}
+
+ public static string CreateNonAsciiStringWithEncodedSize(int encodedSize)
+ {
+ if (encodedSize < 3)
+ {
+ throw new ArgumentException("Illegal encoded size for a string with non-ascii chars.");
+ }
+ var twoByteChar = '\u00DC'; // U-umlaut, UTF8 encoding has 2 bytes
+ var str = new string(twoByteChar, encodedSize / 2);
+ while (CodedOutputStream.ComputeStringSize(str) > encodedSize)
+ {
+ str = str.Substring(1);
+ }
+
+ // add padding of ascii characters to reach the desired encoded size.
+ while (CodedOutputStream.ComputeStringSize(str) < encodedSize)
+ {
+ str += 'a';
+ }
+
+ // Note that for a few specific encodedSize values, it might be impossible to generate
+ // the string with the desired encodedSize using the algorithm above. For testing purposes, checking that
+ // the encoded size we got is actually correct is good enough.
+ if (CodedOutputStream.ComputeStringSize(str) != encodedSize)
+ {
+ throw new InvalidOperationException($"Generated string with wrong encodedSize");
+ }
+ return str;
+ }
}
}
diff --git a/csharp/src/Google.Protobuf.Benchmarks/WrapperBenchmarkMessages.cs b/csharp/src/Google.Protobuf.Benchmarks/WrapperBenchmarkMessages.cs
index 95f613e1ba7f..9db92447ee94 100644
--- a/csharp/src/Google.Protobuf.Benchmarks/WrapperBenchmarkMessages.cs
+++ b/csharp/src/Google.Protobuf.Benchmarks/WrapperBenchmarkMessages.cs
@@ -2073,6 +2073,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (doubleField1_ != null) {
_single_doubleField1_codec.WriteTagAndValue(output, DoubleField1);
}
@@ -2410,7 +2413,351 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (doubleField1_ != null) {
+ _single_doubleField1_codec.WriteTagAndValue(ref output, DoubleField1);
+ }
+ if (int64Field2_ != null) {
+ _single_int64Field2_codec.WriteTagAndValue(ref output, Int64Field2);
+ }
+ if (int64Field3_ != null) {
+ _single_int64Field3_codec.WriteTagAndValue(ref output, Int64Field3);
+ }
+ if (int64Field4_ != null) {
+ _single_int64Field4_codec.WriteTagAndValue(ref output, Int64Field4);
+ }
+ if (doubleField7_ != null) {
+ _single_doubleField7_codec.WriteTagAndValue(ref output, DoubleField7);
+ }
+ if (doubleField8_ != null) {
+ _single_doubleField8_codec.WriteTagAndValue(ref output, DoubleField8);
+ }
+ if (doubleField9_ != null) {
+ _single_doubleField9_codec.WriteTagAndValue(ref output, DoubleField9);
+ }
+ if (doubleField10_ != null) {
+ _single_doubleField10_codec.WriteTagAndValue(ref output, DoubleField10);
+ }
+ if (doubleField11_ != null) {
+ _single_doubleField11_codec.WriteTagAndValue(ref output, DoubleField11);
+ }
+ if (doubleField14_ != null) {
+ _single_doubleField14_codec.WriteTagAndValue(ref output, DoubleField14);
+ }
+ if (doubleField15_ != null) {
+ _single_doubleField15_codec.WriteTagAndValue(ref output, DoubleField15);
+ }
+ if (int64Field19_ != null) {
+ _single_int64Field19_codec.WriteTagAndValue(ref output, Int64Field19);
+ }
+ if (doubleField20_ != null) {
+ _single_doubleField20_codec.WriteTagAndValue(ref output, DoubleField20);
+ }
+ if (doubleField21_ != null) {
+ _single_doubleField21_codec.WriteTagAndValue(ref output, DoubleField21);
+ }
+ if (doubleField22_ != null) {
+ _single_doubleField22_codec.WriteTagAndValue(ref output, DoubleField22);
+ }
+ if (doubleField25_ != null) {
+ _single_doubleField25_codec.WriteTagAndValue(ref output, DoubleField25);
+ }
+ if (int64Field26_ != null) {
+ _single_int64Field26_codec.WriteTagAndValue(ref output, Int64Field26);
+ }
+ if (doubleField28_ != null) {
+ _single_doubleField28_codec.WriteTagAndValue(ref output, DoubleField28);
+ }
+ if (doubleField29_ != null) {
+ _single_doubleField29_codec.WriteTagAndValue(ref output, DoubleField29);
+ }
+ if (doubleField30_ != null) {
+ _single_doubleField30_codec.WriteTagAndValue(ref output, DoubleField30);
+ }
+ if (doubleField31_ != null) {
+ _single_doubleField31_codec.WriteTagAndValue(ref output, DoubleField31);
+ }
+ if (int64Field32_ != null) {
+ _single_int64Field32_codec.WriteTagAndValue(ref output, Int64Field32);
+ }
+ if (int64Field37_ != null) {
+ _single_int64Field37_codec.WriteTagAndValue(ref output, Int64Field37);
+ }
+ if (doubleField38_ != null) {
+ _single_doubleField38_codec.WriteTagAndValue(ref output, DoubleField38);
+ }
+ if (interactions_ != null) {
+ _single_interactions_codec.WriteTagAndValue(ref output, Interactions);
+ }
+ if (doubleField40_ != null) {
+ _single_doubleField40_codec.WriteTagAndValue(ref output, DoubleField40);
+ }
+ if (int64Field41_ != null) {
+ _single_int64Field41_codec.WriteTagAndValue(ref output, Int64Field41);
+ }
+ if (doubleField42_ != null) {
+ _single_doubleField42_codec.WriteTagAndValue(ref output, DoubleField42);
+ }
+ if (int64Field43_ != null) {
+ _single_int64Field43_codec.WriteTagAndValue(ref output, Int64Field43);
+ }
+ if (int64Field44_ != null) {
+ _single_int64Field44_codec.WriteTagAndValue(ref output, Int64Field44);
+ }
+ if (doubleField45_ != null) {
+ _single_doubleField45_codec.WriteTagAndValue(ref output, DoubleField45);
+ }
+ if (doubleField46_ != null) {
+ _single_doubleField46_codec.WriteTagAndValue(ref output, DoubleField46);
+ }
+ if (doubleField47_ != null) {
+ _single_doubleField47_codec.WriteTagAndValue(ref output, DoubleField47);
+ }
+ if (doubleField48_ != null) {
+ _single_doubleField48_codec.WriteTagAndValue(ref output, DoubleField48);
+ }
+ if (doubleField49_ != null) {
+ _single_doubleField49_codec.WriteTagAndValue(ref output, DoubleField49);
+ }
+ if (doubleField50_ != null) {
+ _single_doubleField50_codec.WriteTagAndValue(ref output, DoubleField50);
+ }
+ if (doubleField51_ != null) {
+ _single_doubleField51_codec.WriteTagAndValue(ref output, DoubleField51);
+ }
+ if (doubleField52_ != null) {
+ _single_doubleField52_codec.WriteTagAndValue(ref output, DoubleField52);
+ }
+ if (doubleField53_ != null) {
+ _single_doubleField53_codec.WriteTagAndValue(ref output, DoubleField53);
+ }
+ if (doubleField54_ != null) {
+ _single_doubleField54_codec.WriteTagAndValue(ref output, DoubleField54);
+ }
+ if (doubleField55_ != null) {
+ _single_doubleField55_codec.WriteTagAndValue(ref output, DoubleField55);
+ }
+ if (doubleField56_ != null) {
+ _single_doubleField56_codec.WriteTagAndValue(ref output, DoubleField56);
+ }
+ if (doubleField57_ != null) {
+ _single_doubleField57_codec.WriteTagAndValue(ref output, DoubleField57);
+ }
+ if (doubleField58_ != null) {
+ _single_doubleField58_codec.WriteTagAndValue(ref output, DoubleField58);
+ }
+ if (int64Field59_ != null) {
+ _single_int64Field59_codec.WriteTagAndValue(ref output, Int64Field59);
+ }
+ if (int64Field60_ != null) {
+ _single_int64Field60_codec.WriteTagAndValue(ref output, Int64Field60);
+ }
+ if (doubleField62_ != null) {
+ _single_doubleField62_codec.WriteTagAndValue(ref output, DoubleField62);
+ }
+ if (doubleField65_ != null) {
+ _single_doubleField65_codec.WriteTagAndValue(ref output, DoubleField65);
+ }
+ if (doubleField66_ != null) {
+ _single_doubleField66_codec.WriteTagAndValue(ref output, DoubleField66);
+ }
+ if (doubleField67_ != null) {
+ _single_doubleField67_codec.WriteTagAndValue(ref output, DoubleField67);
+ }
+ if (doubleField68_ != null) {
+ _single_doubleField68_codec.WriteTagAndValue(ref output, DoubleField68);
+ }
+ if (doubleField69_ != null) {
+ _single_doubleField69_codec.WriteTagAndValue(ref output, DoubleField69);
+ }
+ if (doubleField70_ != null) {
+ _single_doubleField70_codec.WriteTagAndValue(ref output, DoubleField70);
+ }
+ if (doubleField71_ != null) {
+ _single_doubleField71_codec.WriteTagAndValue(ref output, DoubleField71);
+ }
+ if (doubleField72_ != null) {
+ _single_doubleField72_codec.WriteTagAndValue(ref output, DoubleField72);
+ }
+ if (stringField73_ != null) {
+ _single_stringField73_codec.WriteTagAndValue(ref output, StringField73);
+ }
+ if (stringField74_ != null) {
+ _single_stringField74_codec.WriteTagAndValue(ref output, StringField74);
+ }
+ if (doubleField75_ != null) {
+ _single_doubleField75_codec.WriteTagAndValue(ref output, DoubleField75);
+ }
+ if (doubleField77_ != null) {
+ _single_doubleField77_codec.WriteTagAndValue(ref output, DoubleField77);
+ }
+ if (doubleField78_ != null) {
+ _single_doubleField78_codec.WriteTagAndValue(ref output, DoubleField78);
+ }
+ if (doubleField79_ != null) {
+ _single_doubleField79_codec.WriteTagAndValue(ref output, DoubleField79);
+ }
+ if (EnumField80 != 0) {
+ output.WriteRawTag(128, 5);
+ output.WriteInt32(EnumField80);
+ }
+ if (EnumField81 != 0) {
+ output.WriteRawTag(136, 5);
+ output.WriteInt32(EnumField81);
+ }
+ if (int64Field82_ != null) {
+ _single_int64Field82_codec.WriteTagAndValue(ref output, Int64Field82);
+ }
+ if (EnumField83 != 0) {
+ output.WriteRawTag(152, 5);
+ output.WriteInt32(EnumField83);
+ }
+ if (doubleField84_ != null) {
+ _single_doubleField84_codec.WriteTagAndValue(ref output, DoubleField84);
+ }
+ if (int64Field85_ != null) {
+ _single_int64Field85_codec.WriteTagAndValue(ref output, Int64Field85);
+ }
+ if (int64Field86_ != null) {
+ _single_int64Field86_codec.WriteTagAndValue(ref output, Int64Field86);
+ }
+ if (int64Field87_ != null) {
+ _single_int64Field87_codec.WriteTagAndValue(ref output, Int64Field87);
+ }
+ if (doubleField88_ != null) {
+ _single_doubleField88_codec.WriteTagAndValue(ref output, DoubleField88);
+ }
+ if (doubleField89_ != null) {
+ _single_doubleField89_codec.WriteTagAndValue(ref output, DoubleField89);
+ }
+ if (doubleField90_ != null) {
+ _single_doubleField90_codec.WriteTagAndValue(ref output, DoubleField90);
+ }
+ if (doubleField91_ != null) {
+ _single_doubleField91_codec.WriteTagAndValue(ref output, DoubleField91);
+ }
+ if (doubleField92_ != null) {
+ _single_doubleField92_codec.WriteTagAndValue(ref output, DoubleField92);
+ }
+ if (doubleField93_ != null) {
+ _single_doubleField93_codec.WriteTagAndValue(ref output, DoubleField93);
+ }
+ if (doubleField94_ != null) {
+ _single_doubleField94_codec.WriteTagAndValue(ref output, DoubleField94);
+ }
+ if (doubleField95_ != null) {
+ _single_doubleField95_codec.WriteTagAndValue(ref output, DoubleField95);
+ }
+ if (doubleField96_ != null) {
+ _single_doubleField96_codec.WriteTagAndValue(ref output, DoubleField96);
+ }
+ if (doubleField97_ != null) {
+ _single_doubleField97_codec.WriteTagAndValue(ref output, DoubleField97);
+ }
+ if (doubleField98_ != null) {
+ _single_doubleField98_codec.WriteTagAndValue(ref output, DoubleField98);
+ }
+ if (doubleField99_ != null) {
+ _single_doubleField99_codec.WriteTagAndValue(ref output, DoubleField99);
+ }
+ repeatedIntField100_.WriteTo(ref output, _repeated_repeatedIntField100_codec);
+ if (doubleField101_ != null) {
+ _single_doubleField101_codec.WriteTagAndValue(ref output, DoubleField101);
+ }
+ if (doubleField102_ != null) {
+ _single_doubleField102_codec.WriteTagAndValue(ref output, DoubleField102);
+ }
+ if (doubleField103_ != null) {
+ _single_doubleField103_codec.WriteTagAndValue(ref output, DoubleField103);
+ }
+ if (doubleField104_ != null) {
+ _single_doubleField104_codec.WriteTagAndValue(ref output, DoubleField104);
+ }
+ if (doubleField105_ != null) {
+ _single_doubleField105_codec.WriteTagAndValue(ref output, DoubleField105);
+ }
+ if (doubleField106_ != null) {
+ _single_doubleField106_codec.WriteTagAndValue(ref output, DoubleField106);
+ }
+ if (int64Field107_ != null) {
+ _single_int64Field107_codec.WriteTagAndValue(ref output, Int64Field107);
+ }
+ if (doubleField108_ != null) {
+ _single_doubleField108_codec.WriteTagAndValue(ref output, DoubleField108);
+ }
+ if (doubleField109_ != null) {
+ _single_doubleField109_codec.WriteTagAndValue(ref output, DoubleField109);
+ }
+ if (int64Field110_ != null) {
+ _single_int64Field110_codec.WriteTagAndValue(ref output, Int64Field110);
+ }
+ if (doubleField111_ != null) {
+ _single_doubleField111_codec.WriteTagAndValue(ref output, DoubleField111);
+ }
+ if (int64Field112_ != null) {
+ _single_int64Field112_codec.WriteTagAndValue(ref output, Int64Field112);
+ }
+ if (doubleField113_ != null) {
+ _single_doubleField113_codec.WriteTagAndValue(ref output, DoubleField113);
+ }
+ if (int64Field114_ != null) {
+ _single_int64Field114_codec.WriteTagAndValue(ref output, Int64Field114);
+ }
+ if (int64Field115_ != null) {
+ _single_int64Field115_codec.WriteTagAndValue(ref output, Int64Field115);
+ }
+ if (doubleField116_ != null) {
+ _single_doubleField116_codec.WriteTagAndValue(ref output, DoubleField116);
+ }
+ if (int64Field117_ != null) {
+ _single_int64Field117_codec.WriteTagAndValue(ref output, Int64Field117);
+ }
+ if (doubleField118_ != null) {
+ _single_doubleField118_codec.WriteTagAndValue(ref output, DoubleField118);
+ }
+ if (doubleField119_ != null) {
+ _single_doubleField119_codec.WriteTagAndValue(ref output, DoubleField119);
+ }
+ if (doubleField120_ != null) {
+ _single_doubleField120_codec.WriteTagAndValue(ref output, DoubleField120);
+ }
+ if (doubleField121_ != null) {
+ _single_doubleField121_codec.WriteTagAndValue(ref output, DoubleField121);
+ }
+ if (doubleField122_ != null) {
+ _single_doubleField122_codec.WriteTagAndValue(ref output, DoubleField122);
+ }
+ if (doubleField123_ != null) {
+ _single_doubleField123_codec.WriteTagAndValue(ref output, DoubleField123);
+ }
+ if (doubleField124_ != null) {
+ _single_doubleField124_codec.WriteTagAndValue(ref output, DoubleField124);
+ }
+ if (int64Field125_ != null) {
+ _single_int64Field125_codec.WriteTagAndValue(ref output, Int64Field125);
+ }
+ if (int64Field126_ != null) {
+ _single_int64Field126_codec.WriteTagAndValue(ref output, Int64Field126);
+ }
+ if (int64Field127_ != null) {
+ _single_int64Field127_codec.WriteTagAndValue(ref output, Int64Field127);
+ }
+ if (doubleField128_ != null) {
+ _single_doubleField128_codec.WriteTagAndValue(ref output, DoubleField128);
+ }
+ if (doubleField129_ != null) {
+ _single_doubleField129_codec.WriteTagAndValue(ref output, DoubleField129);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6495,6 +6842,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (DoubleField1 != 0D) {
output.WriteRawTag(9);
output.WriteDouble(DoubleField1);
@@ -6939,8 +7289,459 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (DoubleField1 != 0D) {
+ output.WriteRawTag(9);
+ output.WriteDouble(DoubleField1);
+ }
+ if (Int64Field2 != 0L) {
+ output.WriteRawTag(16);
+ output.WriteInt64(Int64Field2);
+ }
+ if (Int64Field3 != 0L) {
+ output.WriteRawTag(24);
+ output.WriteInt64(Int64Field3);
+ }
+ if (Int64Field4 != 0L) {
+ output.WriteRawTag(32);
+ output.WriteInt64(Int64Field4);
+ }
+ if (DoubleField7 != 0D) {
+ output.WriteRawTag(57);
+ output.WriteDouble(DoubleField7);
+ }
+ if (DoubleField8 != 0D) {
+ output.WriteRawTag(65);
+ output.WriteDouble(DoubleField8);
+ }
+ if (DoubleField9 != 0D) {
+ output.WriteRawTag(73);
+ output.WriteDouble(DoubleField9);
+ }
+ if (DoubleField10 != 0D) {
+ output.WriteRawTag(81);
+ output.WriteDouble(DoubleField10);
+ }
+ if (DoubleField11 != 0D) {
+ output.WriteRawTag(89);
+ output.WriteDouble(DoubleField11);
+ }
+ if (DoubleField14 != 0D) {
+ output.WriteRawTag(113);
+ output.WriteDouble(DoubleField14);
+ }
+ if (DoubleField15 != 0D) {
+ output.WriteRawTag(121);
+ output.WriteDouble(DoubleField15);
+ }
+ if (Int64Field19 != 0L) {
+ output.WriteRawTag(152, 1);
+ output.WriteInt64(Int64Field19);
+ }
+ if (DoubleField20 != 0D) {
+ output.WriteRawTag(161, 1);
+ output.WriteDouble(DoubleField20);
+ }
+ if (DoubleField21 != 0D) {
+ output.WriteRawTag(169, 1);
+ output.WriteDouble(DoubleField21);
+ }
+ if (DoubleField22 != 0D) {
+ output.WriteRawTag(177, 1);
+ output.WriteDouble(DoubleField22);
+ }
+ if (DoubleField25 != 0D) {
+ output.WriteRawTag(201, 1);
+ output.WriteDouble(DoubleField25);
+ }
+ if (Int64Field26 != 0L) {
+ output.WriteRawTag(208, 1);
+ output.WriteInt64(Int64Field26);
+ }
+ if (DoubleField28 != 0D) {
+ output.WriteRawTag(225, 1);
+ output.WriteDouble(DoubleField28);
+ }
+ if (DoubleField29 != 0D) {
+ output.WriteRawTag(233, 1);
+ output.WriteDouble(DoubleField29);
+ }
+ if (DoubleField30 != 0D) {
+ output.WriteRawTag(241, 1);
+ output.WriteDouble(DoubleField30);
+ }
+ if (DoubleField31 != 0D) {
+ output.WriteRawTag(249, 1);
+ output.WriteDouble(DoubleField31);
+ }
+ if (Int64Field32 != 0L) {
+ output.WriteRawTag(128, 2);
+ output.WriteInt64(Int64Field32);
+ }
+ if (Int64Field37 != 0L) {
+ output.WriteRawTag(168, 2);
+ output.WriteInt64(Int64Field37);
+ }
+ if (DoubleField38 != 0D) {
+ output.WriteRawTag(177, 2);
+ output.WriteDouble(DoubleField38);
+ }
+ if (Interactions != 0L) {
+ output.WriteRawTag(184, 2);
+ output.WriteInt64(Interactions);
+ }
+ if (DoubleField40 != 0D) {
+ output.WriteRawTag(193, 2);
+ output.WriteDouble(DoubleField40);
+ }
+ if (Int64Field41 != 0L) {
+ output.WriteRawTag(200, 2);
+ output.WriteInt64(Int64Field41);
+ }
+ if (DoubleField42 != 0D) {
+ output.WriteRawTag(209, 2);
+ output.WriteDouble(DoubleField42);
+ }
+ if (Int64Field43 != 0L) {
+ output.WriteRawTag(216, 2);
+ output.WriteInt64(Int64Field43);
+ }
+ if (Int64Field44 != 0L) {
+ output.WriteRawTag(224, 2);
+ output.WriteInt64(Int64Field44);
+ }
+ if (DoubleField45 != 0D) {
+ output.WriteRawTag(233, 2);
+ output.WriteDouble(DoubleField45);
+ }
+ if (DoubleField46 != 0D) {
+ output.WriteRawTag(241, 2);
+ output.WriteDouble(DoubleField46);
+ }
+ if (DoubleField47 != 0D) {
+ output.WriteRawTag(249, 2);
+ output.WriteDouble(DoubleField47);
+ }
+ if (DoubleField48 != 0D) {
+ output.WriteRawTag(129, 3);
+ output.WriteDouble(DoubleField48);
+ }
+ if (DoubleField49 != 0D) {
+ output.WriteRawTag(137, 3);
+ output.WriteDouble(DoubleField49);
+ }
+ if (DoubleField50 != 0D) {
+ output.WriteRawTag(145, 3);
+ output.WriteDouble(DoubleField50);
+ }
+ if (DoubleField51 != 0D) {
+ output.WriteRawTag(153, 3);
+ output.WriteDouble(DoubleField51);
+ }
+ if (DoubleField52 != 0D) {
+ output.WriteRawTag(161, 3);
+ output.WriteDouble(DoubleField52);
+ }
+ if (DoubleField53 != 0D) {
+ output.WriteRawTag(169, 3);
+ output.WriteDouble(DoubleField53);
+ }
+ if (DoubleField54 != 0D) {
+ output.WriteRawTag(177, 3);
+ output.WriteDouble(DoubleField54);
+ }
+ if (DoubleField55 != 0D) {
+ output.WriteRawTag(185, 3);
+ output.WriteDouble(DoubleField55);
+ }
+ if (DoubleField56 != 0D) {
+ output.WriteRawTag(193, 3);
+ output.WriteDouble(DoubleField56);
+ }
+ if (DoubleField57 != 0D) {
+ output.WriteRawTag(201, 3);
+ output.WriteDouble(DoubleField57);
+ }
+ if (DoubleField58 != 0D) {
+ output.WriteRawTag(209, 3);
+ output.WriteDouble(DoubleField58);
+ }
+ if (Int64Field59 != 0L) {
+ output.WriteRawTag(216, 3);
+ output.WriteInt64(Int64Field59);
+ }
+ if (Int64Field60 != 0L) {
+ output.WriteRawTag(224, 3);
+ output.WriteInt64(Int64Field60);
+ }
+ if (DoubleField62 != 0D) {
+ output.WriteRawTag(241, 3);
+ output.WriteDouble(DoubleField62);
+ }
+ if (DoubleField65 != 0D) {
+ output.WriteRawTag(137, 4);
+ output.WriteDouble(DoubleField65);
+ }
+ if (DoubleField66 != 0D) {
+ output.WriteRawTag(145, 4);
+ output.WriteDouble(DoubleField66);
+ }
+ if (DoubleField67 != 0D) {
+ output.WriteRawTag(153, 4);
+ output.WriteDouble(DoubleField67);
+ }
+ if (DoubleField68 != 0D) {
+ output.WriteRawTag(161, 4);
+ output.WriteDouble(DoubleField68);
+ }
+ if (DoubleField69 != 0D) {
+ output.WriteRawTag(169, 4);
+ output.WriteDouble(DoubleField69);
+ }
+ if (DoubleField70 != 0D) {
+ output.WriteRawTag(177, 4);
+ output.WriteDouble(DoubleField70);
+ }
+ if (DoubleField71 != 0D) {
+ output.WriteRawTag(185, 4);
+ output.WriteDouble(DoubleField71);
+ }
+ if (DoubleField72 != 0D) {
+ output.WriteRawTag(193, 4);
+ output.WriteDouble(DoubleField72);
+ }
+ if (StringField73.Length != 0) {
+ output.WriteRawTag(202, 4);
+ output.WriteString(StringField73);
+ }
+ if (StringField74.Length != 0) {
+ output.WriteRawTag(210, 4);
+ output.WriteString(StringField74);
+ }
+ if (DoubleField75 != 0D) {
+ output.WriteRawTag(217, 4);
+ output.WriteDouble(DoubleField75);
+ }
+ if (DoubleField77 != 0D) {
+ output.WriteRawTag(233, 4);
+ output.WriteDouble(DoubleField77);
+ }
+ if (DoubleField78 != 0D) {
+ output.WriteRawTag(241, 4);
+ output.WriteDouble(DoubleField78);
+ }
+ if (DoubleField79 != 0D) {
+ output.WriteRawTag(249, 4);
+ output.WriteDouble(DoubleField79);
+ }
+ if (EnumField80 != 0) {
+ output.WriteRawTag(128, 5);
+ output.WriteInt32(EnumField80);
+ }
+ if (EnumField81 != 0) {
+ output.WriteRawTag(136, 5);
+ output.WriteInt32(EnumField81);
+ }
+ if (Int64Field82 != 0L) {
+ output.WriteRawTag(144, 5);
+ output.WriteInt64(Int64Field82);
+ }
+ if (EnumField83 != 0) {
+ output.WriteRawTag(152, 5);
+ output.WriteInt32(EnumField83);
+ }
+ if (DoubleField84 != 0D) {
+ output.WriteRawTag(161, 5);
+ output.WriteDouble(DoubleField84);
+ }
+ if (Int64Field85 != 0L) {
+ output.WriteRawTag(168, 5);
+ output.WriteInt64(Int64Field85);
+ }
+ if (Int64Field86 != 0L) {
+ output.WriteRawTag(176, 5);
+ output.WriteInt64(Int64Field86);
+ }
+ if (Int64Field87 != 0L) {
+ output.WriteRawTag(184, 5);
+ output.WriteInt64(Int64Field87);
+ }
+ if (DoubleField88 != 0D) {
+ output.WriteRawTag(193, 5);
+ output.WriteDouble(DoubleField88);
+ }
+ if (DoubleField89 != 0D) {
+ output.WriteRawTag(201, 5);
+ output.WriteDouble(DoubleField89);
+ }
+ if (DoubleField90 != 0D) {
+ output.WriteRawTag(209, 5);
+ output.WriteDouble(DoubleField90);
+ }
+ if (DoubleField91 != 0D) {
+ output.WriteRawTag(217, 5);
+ output.WriteDouble(DoubleField91);
+ }
+ if (DoubleField92 != 0D) {
+ output.WriteRawTag(225, 5);
+ output.WriteDouble(DoubleField92);
+ }
+ if (DoubleField93 != 0D) {
+ output.WriteRawTag(233, 5);
+ output.WriteDouble(DoubleField93);
+ }
+ if (DoubleField94 != 0D) {
+ output.WriteRawTag(241, 5);
+ output.WriteDouble(DoubleField94);
+ }
+ if (DoubleField95 != 0D) {
+ output.WriteRawTag(249, 5);
+ output.WriteDouble(DoubleField95);
+ }
+ if (DoubleField96 != 0D) {
+ output.WriteRawTag(129, 6);
+ output.WriteDouble(DoubleField96);
+ }
+ if (DoubleField97 != 0D) {
+ output.WriteRawTag(137, 6);
+ output.WriteDouble(DoubleField97);
+ }
+ if (DoubleField98 != 0D) {
+ output.WriteRawTag(145, 6);
+ output.WriteDouble(DoubleField98);
+ }
+ if (DoubleField99 != 0D) {
+ output.WriteRawTag(153, 6);
+ output.WriteDouble(DoubleField99);
+ }
+ repeatedIntField100_.WriteTo(ref output, _repeated_repeatedIntField100_codec);
+ if (DoubleField101 != 0D) {
+ output.WriteRawTag(169, 6);
+ output.WriteDouble(DoubleField101);
+ }
+ if (DoubleField102 != 0D) {
+ output.WriteRawTag(177, 6);
+ output.WriteDouble(DoubleField102);
+ }
+ if (DoubleField103 != 0D) {
+ output.WriteRawTag(185, 6);
+ output.WriteDouble(DoubleField103);
+ }
+ if (DoubleField104 != 0D) {
+ output.WriteRawTag(193, 6);
+ output.WriteDouble(DoubleField104);
+ }
+ if (DoubleField105 != 0D) {
+ output.WriteRawTag(201, 6);
+ output.WriteDouble(DoubleField105);
+ }
+ if (DoubleField106 != 0D) {
+ output.WriteRawTag(209, 6);
+ output.WriteDouble(DoubleField106);
+ }
+ if (Int64Field107 != 0L) {
+ output.WriteRawTag(216, 6);
+ output.WriteInt64(Int64Field107);
+ }
+ if (DoubleField108 != 0D) {
+ output.WriteRawTag(225, 6);
+ output.WriteDouble(DoubleField108);
+ }
+ if (DoubleField109 != 0D) {
+ output.WriteRawTag(233, 6);
+ output.WriteDouble(DoubleField109);
+ }
+ if (Int64Field110 != 0L) {
+ output.WriteRawTag(240, 6);
+ output.WriteInt64(Int64Field110);
+ }
+ if (DoubleField111 != 0D) {
+ output.WriteRawTag(249, 6);
+ output.WriteDouble(DoubleField111);
+ }
+ if (Int64Field112 != 0L) {
+ output.WriteRawTag(128, 7);
+ output.WriteInt64(Int64Field112);
+ }
+ if (DoubleField113 != 0D) {
+ output.WriteRawTag(137, 7);
+ output.WriteDouble(DoubleField113);
+ }
+ if (Int64Field114 != 0L) {
+ output.WriteRawTag(144, 7);
+ output.WriteInt64(Int64Field114);
+ }
+ if (Int64Field115 != 0L) {
+ output.WriteRawTag(152, 7);
+ output.WriteInt64(Int64Field115);
+ }
+ if (DoubleField116 != 0D) {
+ output.WriteRawTag(161, 7);
+ output.WriteDouble(DoubleField116);
+ }
+ if (Int64Field117 != 0L) {
+ output.WriteRawTag(168, 7);
+ output.WriteInt64(Int64Field117);
+ }
+ if (DoubleField118 != 0D) {
+ output.WriteRawTag(177, 7);
+ output.WriteDouble(DoubleField118);
+ }
+ if (DoubleField119 != 0D) {
+ output.WriteRawTag(185, 7);
+ output.WriteDouble(DoubleField119);
+ }
+ if (DoubleField120 != 0D) {
+ output.WriteRawTag(193, 7);
+ output.WriteDouble(DoubleField120);
+ }
+ if (DoubleField121 != 0D) {
+ output.WriteRawTag(201, 7);
+ output.WriteDouble(DoubleField121);
+ }
+ if (DoubleField122 != 0D) {
+ output.WriteRawTag(209, 7);
+ output.WriteDouble(DoubleField122);
+ }
+ if (DoubleField123 != 0D) {
+ output.WriteRawTag(217, 7);
+ output.WriteDouble(DoubleField123);
+ }
+ if (DoubleField124 != 0D) {
+ output.WriteRawTag(225, 7);
+ output.WriteDouble(DoubleField124);
+ }
+ if (Int64Field125 != 0L) {
+ output.WriteRawTag(232, 7);
+ output.WriteInt64(Int64Field125);
+ }
+ if (Int64Field126 != 0L) {
+ output.WriteRawTag(240, 7);
+ output.WriteInt64(Int64Field126);
+ }
+ if (Int64Field127 != 0L) {
+ output.WriteRawTag(248, 7);
+ output.WriteInt64(Int64Field127);
+ }
+ if (DoubleField128 != 0D) {
+ output.WriteRawTag(129, 8);
+ output.WriteDouble(DoubleField128);
+ }
+ if (DoubleField129 != 0D) {
+ output.WriteRawTag(137, 8);
+ output.WriteDouble(DoubleField129);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf.Benchmarks/WriteMessagesBenchmark.cs b/csharp/src/Google.Protobuf.Benchmarks/WriteMessagesBenchmark.cs
new file mode 100644
index 000000000000..5a3bba74d260
--- /dev/null
+++ b/csharp/src/Google.Protobuf.Benchmarks/WriteMessagesBenchmark.cs
@@ -0,0 +1,198 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2019 Google Inc. All rights reserved.
+// https://github.com/protocolbuffers/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using BenchmarkDotNet.Attributes;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Buffers;
+using Google.Protobuf.WellKnownTypes;
+
+namespace Google.Protobuf.Benchmarks
+{
+ ///
+ /// Benchmark that tests writing performance for various messages.
+ ///
+ [MemoryDiagnoser]
+ public class WriteMessagesBenchmark
+ {
+ const int MaxMessages = 100;
+
+ SubTest manyWrapperFieldsTest = new SubTest(ParseMessagesBenchmark.CreateManyWrapperFieldsMessage(), MaxMessages);
+ SubTest manyPrimitiveFieldsTest = new SubTest(ParseMessagesBenchmark.CreateManyPrimitiveFieldsMessage(), MaxMessages);
+ SubTest emptyMessageTest = new SubTest(new Empty(), MaxMessages);
+
+ public IEnumerable MessageCountValues => new[] { 10, 100 };
+
+ [GlobalSetup]
+ public void GlobalSetup()
+ {
+ }
+
+ [Benchmark]
+ public byte[] ManyWrapperFieldsMessage_ToByteArray()
+ {
+ return manyWrapperFieldsTest.ToByteArray();
+ }
+
+ [Benchmark]
+ public byte[] ManyWrapperFieldsMessage_WriteToCodedOutputStream()
+ {
+ return manyWrapperFieldsTest.WriteToCodedOutputStream_PreAllocatedBuffer();
+ }
+
+ [Benchmark]
+ public byte[] ManyWrapperFieldsMessage_WriteToSpan()
+ {
+ return manyWrapperFieldsTest.WriteToSpan_PreAllocatedBuffer();
+ }
+
+
+ [Benchmark]
+ public byte[] ManyPrimitiveFieldsMessage_ToByteArray()
+ {
+ return manyPrimitiveFieldsTest.ToByteArray();
+ }
+
+ [Benchmark]
+ public byte[] ManyPrimitiveFieldsMessage_WriteToCodedOutputStream()
+ {
+ return manyPrimitiveFieldsTest.WriteToCodedOutputStream_PreAllocatedBuffer();
+ }
+
+ [Benchmark]
+ public byte[] ManyPrimitiveFieldsMessage_WriteToSpan()
+ {
+ return manyPrimitiveFieldsTest.WriteToSpan_PreAllocatedBuffer();
+ }
+
+ [Benchmark]
+ public byte[] EmptyMessage_ToByteArray()
+ {
+ return emptyMessageTest.ToByteArray();
+ }
+
+ [Benchmark]
+ public byte[] EmptyMessage_WriteToCodedOutputStream()
+ {
+ return emptyMessageTest.WriteToCodedOutputStream_PreAllocatedBuffer();
+ }
+
+ [Benchmark]
+ public byte[] EmptyMessage_WriteToSpan()
+ {
+ return emptyMessageTest.WriteToSpan_PreAllocatedBuffer();
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(MessageCountValues))]
+ public void ManyWrapperFieldsMessage_WriteDelimitedMessagesToCodedOutputStream(int messageCount)
+ {
+ manyWrapperFieldsTest.WriteDelimitedMessagesToCodedOutputStream_PreAllocatedBuffer(messageCount);
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(MessageCountValues))]
+ public void ManyWrapperFieldsMessage_WriteDelimitedMessagesToSpan(int messageCount)
+ {
+ manyWrapperFieldsTest.WriteDelimitedMessagesToSpan_PreAllocatedBuffer(messageCount);
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(MessageCountValues))]
+ public void ManyPrimitiveFieldsMessage_WriteDelimitedMessagesToCodedOutputStream(int messageCount)
+ {
+ manyPrimitiveFieldsTest.WriteDelimitedMessagesToCodedOutputStream_PreAllocatedBuffer(messageCount);
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(MessageCountValues))]
+ public void ManyPrimitiveFieldsMessage_WriteDelimitedMessagesToSpan(int messageCount)
+ {
+ manyPrimitiveFieldsTest.WriteDelimitedMessagesToSpan_PreAllocatedBuffer(messageCount);
+ }
+
+ private class SubTest
+ {
+ private readonly IMessage message;
+ private readonly byte[] outputBuffer;
+ private readonly byte[] multipleMessagesOutputBuffer;
+
+ public SubTest(IMessage message, int maxMessageCount)
+ {
+ this.message = message;
+
+ int messageSize = message.CalculateSize();
+ this.outputBuffer = new byte[messageSize];
+ this.multipleMessagesOutputBuffer = new byte[maxMessageCount * (messageSize + CodedOutputStream.ComputeLengthSize(messageSize))];
+ }
+
+ public byte[] ToByteArray() => message.ToByteArray();
+
+ public byte[] WriteToCodedOutputStream_PreAllocatedBuffer()
+ {
+ var cos = new CodedOutputStream(outputBuffer); // use pre-existing output buffer
+ message.WriteTo(cos);
+ return outputBuffer;
+ }
+
+ public byte[] WriteToSpan_PreAllocatedBuffer()
+ {
+ var span = new Span(outputBuffer); // use pre-existing output buffer
+ message.WriteTo(span);
+ return outputBuffer;
+ }
+
+ public byte[] WriteDelimitedMessagesToCodedOutputStream_PreAllocatedBuffer(int messageCount)
+ {
+ var cos = new CodedOutputStream(multipleMessagesOutputBuffer); // use pre-existing output buffer
+ for (int i = 0; i < messageCount; i++)
+ {
+ cos.WriteMessage(message);
+ }
+ return multipleMessagesOutputBuffer;
+ }
+
+ public byte[] WriteDelimitedMessagesToSpan_PreAllocatedBuffer(int messageCount)
+ {
+ var span = new Span(multipleMessagesOutputBuffer); // use pre-existing output buffer
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ for (int i = 0; i < messageCount; i++)
+ {
+ ctx.WriteMessage(message);
+ }
+ return multipleMessagesOutputBuffer;
+ }
+ }
+ }
+}
diff --git a/csharp/src/Google.Protobuf.Benchmarks/WriteRawPrimitivesBenchmark.cs b/csharp/src/Google.Protobuf.Benchmarks/WriteRawPrimitivesBenchmark.cs
new file mode 100644
index 000000000000..891b877b68f7
--- /dev/null
+++ b/csharp/src/Google.Protobuf.Benchmarks/WriteRawPrimitivesBenchmark.cs
@@ -0,0 +1,467 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2019 Google Inc. All rights reserved.
+// https://github.com/protocolbuffers/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using BenchmarkDotNet.Attributes;
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Buffers;
+using System.Text;
+
+namespace Google.Protobuf.Benchmarks
+{
+ ///
+ /// Benchmarks throughput when writing raw primitives.
+ ///
+ [MemoryDiagnoser]
+ public class WriteRawPrimitivesBenchmark
+ {
+ // key is the encodedSize of varint values
+ Dictionary varint32Values;
+ Dictionary varint64Values;
+
+ double[] doubleValues;
+ float[] floatValues;
+
+ // key is the encodedSize of string values
+ Dictionary stringValues;
+
+ // key is the encodedSize of string values
+ Dictionary nonAsciiStringValues;
+
+ // key is the encodedSize of string values
+ Dictionary byteStringValues;
+
+ // the buffer to which all the data will be written
+ byte[] outputBuffer;
+
+ Random random = new Random(417384220); // random but deterministic seed
+
+ public IEnumerable StringEncodedSizes => new[] { 1, 4, 10, 105, 10080 };
+
+ public IEnumerable NonAsciiStringEncodedSizes => new[] { 4, 10, 105, 10080 };
+
+ [GlobalSetup]
+ public void GlobalSetup()
+ {
+ outputBuffer = new byte[BytesToWrite];
+
+ varint32Values = new Dictionary();
+ varint64Values = new Dictionary();
+ for (int encodedSize = 1; encodedSize <= 10; encodedSize++)
+ {
+ if (encodedSize <= 5)
+ {
+ varint32Values.Add(encodedSize, CreateRandomVarints32(random, BytesToWrite / encodedSize, encodedSize));
+ }
+ varint64Values.Add(encodedSize, CreateRandomVarints64(random, BytesToWrite / encodedSize, encodedSize));
+ }
+
+ doubleValues = CreateRandomDoubles(random, BytesToWrite / sizeof(double));
+ floatValues = CreateRandomFloats(random, BytesToWrite / sizeof(float));
+
+ stringValues = new Dictionary();
+
+ byteStringValues = new Dictionary();
+ foreach(var encodedSize in StringEncodedSizes)
+ {
+ stringValues.Add(encodedSize, CreateStrings(BytesToWrite / encodedSize, encodedSize));
+ byteStringValues.Add(encodedSize, CreateByteStrings(BytesToWrite / encodedSize, encodedSize));
+ }
+
+ nonAsciiStringValues = new Dictionary();
+ foreach(var encodedSize in NonAsciiStringEncodedSizes)
+ {
+ nonAsciiStringValues.Add(encodedSize, CreateNonAsciiStrings(BytesToWrite / encodedSize, encodedSize));
+ }
+ }
+
+ // Total number of bytes that each benchmark will write.
+ // Measuring the time taken to write buffer of given size makes it easier to compare parsing speed for different
+ // types and makes it easy to calculate the througput (in MB/s)
+ // 10800 bytes is chosen because it is divisible by all possible encoded sizes for all primitive types {1..10}
+ [Params(10080)]
+ public int BytesToWrite { get; set; }
+
+ [Benchmark]
+ [Arguments(1)]
+ [Arguments(2)]
+ [Arguments(3)]
+ [Arguments(4)]
+ [Arguments(5)]
+ public void WriteRawVarint32_CodedOutputStream(int encodedSize)
+ {
+ var values = varint32Values[encodedSize];
+ var cos = new CodedOutputStream(outputBuffer);
+ foreach (var value in values)
+ {
+ cos.WriteRawVarint32(value);
+ }
+ cos.Flush();
+ cos.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ [Arguments(1)]
+ [Arguments(2)]
+ [Arguments(3)]
+ [Arguments(4)]
+ [Arguments(5)]
+ public void WriteRawVarint32_WriteContext(int encodedSize)
+ {
+ var values = varint32Values[encodedSize];
+ var span = new Span(outputBuffer);
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ foreach (var value in values)
+ {
+ ctx.WriteUInt32(value);
+ }
+ ctx.Flush();
+ ctx.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ [Arguments(1)]
+ [Arguments(2)]
+ [Arguments(3)]
+ [Arguments(4)]
+ [Arguments(5)]
+ [Arguments(6)]
+ [Arguments(7)]
+ [Arguments(8)]
+ [Arguments(9)]
+ [Arguments(10)]
+ public void WriteRawVarint64_CodedOutputStream(int encodedSize)
+ {
+ var values = varint64Values[encodedSize];
+ var cos = new CodedOutputStream(outputBuffer);
+ foreach (var value in values)
+ {
+ cos.WriteRawVarint64(value);
+ }
+ cos.Flush();
+ cos.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ [Arguments(1)]
+ [Arguments(2)]
+ [Arguments(3)]
+ [Arguments(4)]
+ [Arguments(5)]
+ [Arguments(6)]
+ [Arguments(7)]
+ [Arguments(8)]
+ [Arguments(9)]
+ [Arguments(10)]
+ public void WriteRawVarint64_WriteContext(int encodedSize)
+ {
+ var values = varint64Values[encodedSize];
+ var span = new Span(outputBuffer);
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ foreach (var value in values)
+ {
+ ctx.WriteUInt64(value);
+ }
+ ctx.Flush();
+ ctx.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ public void WriteFixed32_CodedOutputStream()
+ {
+ const int encodedSize = sizeof(uint);
+ var cos = new CodedOutputStream(outputBuffer);
+ for(int i = 0; i < BytesToWrite / encodedSize; i++)
+ {
+ cos.WriteFixed32(12345);
+ }
+ cos.Flush();
+ cos.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ public void WriteFixed32_WriteContext()
+ {
+ const int encodedSize = sizeof(uint);
+ var span = new Span(outputBuffer);
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ for (uint i = 0; i < BytesToWrite / encodedSize; i++)
+ {
+ ctx.WriteFixed32(12345);
+ }
+ ctx.Flush();
+ ctx.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ public void WriteFixed64_CodedOutputStream()
+ {
+ const int encodedSize = sizeof(ulong);
+ var cos = new CodedOutputStream(outputBuffer);
+ for(int i = 0; i < BytesToWrite / encodedSize; i++)
+ {
+ cos.WriteFixed64(123456789);
+ }
+ cos.Flush();
+ cos.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ public void WriteFixed64_WriteContext()
+ {
+ const int encodedSize = sizeof(ulong);
+ var span = new Span(outputBuffer);
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ for (uint i = 0; i < BytesToWrite / encodedSize; i++)
+ {
+ ctx.WriteFixed64(123456789);
+ }
+ ctx.Flush();
+ ctx.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ public void WriteRawFloat_CodedOutputStream()
+ {
+ var cos = new CodedOutputStream(outputBuffer);
+ foreach (var value in floatValues)
+ {
+ cos.WriteFloat(value);
+ }
+ cos.Flush();
+ cos.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ public void WriteRawFloat_WriteContext()
+ {
+ var span = new Span(outputBuffer);
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ foreach (var value in floatValues)
+ {
+ ctx.WriteFloat(value);
+ }
+ ctx.Flush();
+ ctx.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ public void WriteRawDouble_CodedOutputStream()
+ {
+ var cos = new CodedOutputStream(outputBuffer);
+ foreach (var value in doubleValues)
+ {
+ cos.WriteDouble(value);
+ }
+ cos.Flush();
+ cos.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ public void WriteRawDouble_WriteContext()
+ {
+ var span = new Span(outputBuffer);
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ foreach (var value in doubleValues)
+ {
+ ctx.WriteDouble(value);
+ }
+ ctx.Flush();
+ ctx.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(StringEncodedSizes))]
+ public void WriteString_CodedOutputStream(int encodedSize)
+ {
+ var values = stringValues[encodedSize];
+ var cos = new CodedOutputStream(outputBuffer);
+ foreach (var value in values)
+ {
+ cos.WriteString(value);
+ }
+ cos.Flush();
+ cos.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(StringEncodedSizes))]
+ public void WriteString_WriteContext(int encodedSize)
+ {
+ var values = stringValues[encodedSize];
+ var span = new Span(outputBuffer);
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ foreach (var value in values)
+ {
+ ctx.WriteString(value);
+ }
+ ctx.Flush();
+ ctx.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(NonAsciiStringEncodedSizes))]
+ public void WriteNonAsciiString_CodedOutputStream(int encodedSize)
+ {
+ var values = nonAsciiStringValues[encodedSize];
+ var cos = new CodedOutputStream(outputBuffer);
+ foreach (var value in values)
+ {
+ cos.WriteString(value);
+ }
+ cos.Flush();
+ cos.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(NonAsciiStringEncodedSizes))]
+ public void WriteNonAsciiString_WriteContext(int encodedSize)
+ {
+ var values = nonAsciiStringValues[encodedSize];
+ var span = new Span(outputBuffer);
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ foreach (var value in values)
+ {
+ ctx.WriteString(value);
+ }
+ ctx.Flush();
+ ctx.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(StringEncodedSizes))]
+ public void WriteBytes_CodedOutputStream(int encodedSize)
+ {
+ var values = byteStringValues[encodedSize];
+ var cos = new CodedOutputStream(outputBuffer);
+ foreach (var value in values)
+ {
+ cos.WriteBytes(value);
+ }
+ cos.Flush();
+ cos.CheckNoSpaceLeft();
+ }
+
+ [Benchmark]
+ [ArgumentsSource(nameof(StringEncodedSizes))]
+ public void WriteBytes_WriteContext(int encodedSize)
+ {
+ var values = byteStringValues[encodedSize];
+ var span = new Span(outputBuffer);
+ WriteContext.Initialize(ref span, out WriteContext ctx);
+ foreach (var value in values)
+ {
+ ctx.WriteBytes(value);
+ }
+ ctx.Flush();
+ ctx.CheckNoSpaceLeft();
+ }
+
+ private static uint[] CreateRandomVarints32(Random random, int valueCount, int encodedSize)
+ {
+ var result = new uint[valueCount];
+ for (int i = 0; i < valueCount; i++)
+ {
+ result[i] = (uint) ParseRawPrimitivesBenchmark.RandomUnsignedVarint(random, encodedSize, true);
+ }
+ return result;
+ }
+
+ private static ulong[] CreateRandomVarints64(Random random, int valueCount, int encodedSize)
+ {
+ var result = new ulong[valueCount];
+ for (int i = 0; i < valueCount; i++)
+ {
+ result[i] = ParseRawPrimitivesBenchmark.RandomUnsignedVarint(random, encodedSize, false);
+ }
+ return result;
+ }
+
+ private static float[] CreateRandomFloats(Random random, int valueCount)
+ {
+ var result = new float[valueCount];
+ for (int i = 0; i < valueCount; i++)
+ {
+ result[i] = (float)random.NextDouble();
+ }
+ return result;
+ }
+
+ private static double[] CreateRandomDoubles(Random random, int valueCount)
+ {
+ var result = new double[valueCount];
+ for (int i = 0; i < valueCount; i++)
+ {
+ result[i] = random.NextDouble();
+ }
+ return result;
+ }
+
+ private static string[] CreateStrings(int valueCount, int encodedSize)
+ {
+ var str = ParseRawPrimitivesBenchmark.CreateStringWithEncodedSize(encodedSize);
+
+ var result = new string[valueCount];
+ for (int i = 0; i < valueCount; i++)
+ {
+ result[i] = str;
+ }
+ return result;
+ }
+
+ private static string[] CreateNonAsciiStrings(int valueCount, int encodedSize)
+ {
+ var str = ParseRawPrimitivesBenchmark.CreateNonAsciiStringWithEncodedSize(encodedSize);
+
+ var result = new string[valueCount];
+ for (int i = 0; i < valueCount; i++)
+ {
+ result[i] = str;
+ }
+ return result;
+ }
+
+ private static ByteString[] CreateByteStrings(int valueCount, int encodedSize)
+ {
+ var str = ParseRawPrimitivesBenchmark.CreateStringWithEncodedSize(encodedSize);
+
+ var result = new ByteString[valueCount];
+ for (int i = 0; i < valueCount; i++)
+ {
+ result[i] = ByteString.CopyFrom(Encoding.UTF8.GetBytes(str));
+ }
+ return result;
+ }
+ }
+}
diff --git a/csharp/src/Google.Protobuf.Conformance/Conformance.cs b/csharp/src/Google.Protobuf.Conformance/Conformance.cs
index 2c0846643ed6..f26d181a98de 100644
--- a/csharp/src/Google.Protobuf.Conformance/Conformance.cs
+++ b/csharp/src/Google.Protobuf.Conformance/Conformance.cs
@@ -189,11 +189,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
failure_.WriteTo(output, _repeated_failure_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ failure_.WriteTo(ref output, _repeated_failure_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -513,6 +527,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (payloadCase_ == PayloadOneofCase.ProtobufPayload) {
output.WriteRawTag(10);
output.WriteBytes(ProtobufPayload);
@@ -552,7 +569,53 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (payloadCase_ == PayloadOneofCase.ProtobufPayload) {
+ output.WriteRawTag(10);
+ output.WriteBytes(ProtobufPayload);
+ }
+ if (payloadCase_ == PayloadOneofCase.JsonPayload) {
+ output.WriteRawTag(18);
+ output.WriteString(JsonPayload);
+ }
+ if (RequestedOutputFormat != global::Conformance.WireFormat.Unspecified) {
+ output.WriteRawTag(24);
+ output.WriteEnum((int) RequestedOutputFormat);
+ }
+ if (MessageType.Length != 0) {
+ output.WriteRawTag(34);
+ output.WriteString(MessageType);
+ }
+ if (TestCategory != global::Conformance.TestCategory.UnspecifiedTest) {
+ output.WriteRawTag(40);
+ output.WriteEnum((int) TestCategory);
+ }
+ if (jspbEncodingOptions_ != null) {
+ output.WriteRawTag(50);
+ output.WriteMessage(JspbEncodingOptions);
+ }
+ if (payloadCase_ == PayloadOneofCase.JspbPayload) {
+ output.WriteRawTag(58);
+ output.WriteString(JspbPayload);
+ }
+ if (payloadCase_ == PayloadOneofCase.TextPayload) {
+ output.WriteRawTag(66);
+ output.WriteString(TextPayload);
+ }
+ if (PrintUnknownFields != false) {
+ output.WriteRawTag(72);
+ output.WriteBool(PrintUnknownFields);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1009,6 +1072,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (resultCase_ == ResultOneofCase.ParseError) {
output.WriteRawTag(10);
output.WriteString(ParseError);
@@ -1044,7 +1110,49 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (resultCase_ == ResultOneofCase.ParseError) {
+ output.WriteRawTag(10);
+ output.WriteString(ParseError);
+ }
+ if (resultCase_ == ResultOneofCase.RuntimeError) {
+ output.WriteRawTag(18);
+ output.WriteString(RuntimeError);
+ }
+ if (resultCase_ == ResultOneofCase.ProtobufPayload) {
+ output.WriteRawTag(26);
+ output.WriteBytes(ProtobufPayload);
+ }
+ if (resultCase_ == ResultOneofCase.JsonPayload) {
+ output.WriteRawTag(34);
+ output.WriteString(JsonPayload);
+ }
+ if (resultCase_ == ResultOneofCase.Skipped) {
+ output.WriteRawTag(42);
+ output.WriteString(Skipped);
+ }
+ if (resultCase_ == ResultOneofCase.SerializeError) {
+ output.WriteRawTag(50);
+ output.WriteString(SerializeError);
+ }
+ if (resultCase_ == ResultOneofCase.JspbPayload) {
+ output.WriteRawTag(58);
+ output.WriteString(JspbPayload);
+ }
+ if (resultCase_ == ResultOneofCase.TextPayload) {
+ output.WriteRawTag(66);
+ output.WriteString(TextPayload);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1299,6 +1407,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (UseJspbArrayAnyFormat != false) {
output.WriteRawTag(8);
output.WriteBool(UseJspbArrayAnyFormat);
@@ -1306,7 +1417,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (UseJspbArrayAnyFormat != false) {
+ output.WriteRawTag(8);
+ output.WriteBool(UseJspbArrayAnyFormat);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/MapUnittestProto3.cs b/csharp/src/Google.Protobuf.Test.TestProtos/MapUnittestProto3.cs
index 308ccbd649d9..bbf0061f880b 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/MapUnittestProto3.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/MapUnittestProto3.cs
@@ -466,6 +466,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
mapInt32Int32_.WriteTo(output, _map_mapInt32Int32_codec);
mapInt64Int64_.WriteTo(output, _map_mapInt64Int64_codec);
mapUint32Uint32_.WriteTo(output, _map_mapUint32Uint32_codec);
@@ -486,7 +489,34 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ mapInt32Int32_.WriteTo(ref output, _map_mapInt32Int32_codec);
+ mapInt64Int64_.WriteTo(ref output, _map_mapInt64Int64_codec);
+ mapUint32Uint32_.WriteTo(ref output, _map_mapUint32Uint32_codec);
+ mapUint64Uint64_.WriteTo(ref output, _map_mapUint64Uint64_codec);
+ mapSint32Sint32_.WriteTo(ref output, _map_mapSint32Sint32_codec);
+ mapSint64Sint64_.WriteTo(ref output, _map_mapSint64Sint64_codec);
+ mapFixed32Fixed32_.WriteTo(ref output, _map_mapFixed32Fixed32_codec);
+ mapFixed64Fixed64_.WriteTo(ref output, _map_mapFixed64Fixed64_codec);
+ mapSfixed32Sfixed32_.WriteTo(ref output, _map_mapSfixed32Sfixed32_codec);
+ mapSfixed64Sfixed64_.WriteTo(ref output, _map_mapSfixed64Sfixed64_codec);
+ mapInt32Float_.WriteTo(ref output, _map_mapInt32Float_codec);
+ mapInt32Double_.WriteTo(ref output, _map_mapInt32Double_codec);
+ mapBoolBool_.WriteTo(ref output, _map_mapBoolBool_codec);
+ mapStringString_.WriteTo(ref output, _map_mapStringString_codec);
+ mapInt32Bytes_.WriteTo(ref output, _map_mapInt32Bytes_codec);
+ mapInt32Enum_.WriteTo(ref output, _map_mapInt32Enum_codec);
+ mapInt32ForeignMessage_.WriteTo(ref output, _map_mapInt32ForeignMessage_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -790,6 +820,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (testMap_ != null) {
output.WriteRawTag(10);
output.WriteMessage(TestMap);
@@ -797,8 +830,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (testMap_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(TestMap);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -953,11 +1000,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
mapInt32Message_.WriteTo(output, _map_mapInt32Message_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ mapInt32Message_.WriteTo(ref output, _map_mapInt32Message_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1116,12 +1177,27 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
map1_.WriteTo(output, _map_map1_codec);
map2_.WriteTo(output, _map_map2_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ map1_.WriteTo(ref output, _map_map1_codec);
+ map2_.WriteTo(ref output, _map_map2_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1456,6 +1532,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
mapInt32Int32_.WriteTo(output, _map_mapInt32Int32_codec);
mapInt64Int64_.WriteTo(output, _map_mapInt64Int64_codec);
mapUint32Uint32_.WriteTo(output, _map_mapUint32Uint32_codec);
@@ -1474,8 +1553,33 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ mapInt32Int32_.WriteTo(ref output, _map_mapInt32Int32_codec);
+ mapInt64Int64_.WriteTo(ref output, _map_mapInt64Int64_codec);
+ mapUint32Uint32_.WriteTo(ref output, _map_mapUint32Uint32_codec);
+ mapUint64Uint64_.WriteTo(ref output, _map_mapUint64Uint64_codec);
+ mapSint32Sint32_.WriteTo(ref output, _map_mapSint32Sint32_codec);
+ mapSint64Sint64_.WriteTo(ref output, _map_mapSint64Sint64_codec);
+ mapFixed32Fixed32_.WriteTo(ref output, _map_mapFixed32Fixed32_codec);
+ mapFixed64Fixed64_.WriteTo(ref output, _map_mapFixed64Fixed64_codec);
+ mapSfixed32Sfixed32_.WriteTo(ref output, _map_mapSfixed32Sfixed32_codec);
+ mapSfixed64Sfixed64_.WriteTo(ref output, _map_mapSfixed64Sfixed64_codec);
+ mapInt32Float_.WriteTo(ref output, _map_mapInt32Float_codec);
+ mapInt32Double_.WriteTo(ref output, _map_mapInt32Double_codec);
+ mapBoolBool_.WriteTo(ref output, _map_mapBoolBool_codec);
+ mapInt32Enum_.WriteTo(ref output, _map_mapInt32Enum_codec);
+ mapInt32ForeignMessage_.WriteTo(ref output, _map_mapInt32ForeignMessage_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1761,12 +1865,26 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
type_.WriteTo(output, _map_type_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ type_.WriteTo(ref output, _map_type_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1922,12 +2040,26 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
entry_.WriteTo(output, _map_entry_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ entry_.WriteTo(ref output, _map_entry_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/TestMessagesProto2.cs b/csharp/src/Google.Protobuf.Test.TestProtos/TestMessagesProto2.cs
index eb22955dc34c..de1ece351afc 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/TestMessagesProto2.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/TestMessagesProto2.cs
@@ -2561,6 +2561,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasOptionalInt32) {
output.WriteRawTag(8);
output.WriteInt32(OptionalInt32);
@@ -2836,7 +2839,289 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasOptionalInt32) {
+ output.WriteRawTag(8);
+ output.WriteInt32(OptionalInt32);
+ }
+ if (HasOptionalInt64) {
+ output.WriteRawTag(16);
+ output.WriteInt64(OptionalInt64);
+ }
+ if (HasOptionalUint32) {
+ output.WriteRawTag(24);
+ output.WriteUInt32(OptionalUint32);
+ }
+ if (HasOptionalUint64) {
+ output.WriteRawTag(32);
+ output.WriteUInt64(OptionalUint64);
+ }
+ if (HasOptionalSint32) {
+ output.WriteRawTag(40);
+ output.WriteSInt32(OptionalSint32);
+ }
+ if (HasOptionalSint64) {
+ output.WriteRawTag(48);
+ output.WriteSInt64(OptionalSint64);
+ }
+ if (HasOptionalFixed32) {
+ output.WriteRawTag(61);
+ output.WriteFixed32(OptionalFixed32);
+ }
+ if (HasOptionalFixed64) {
+ output.WriteRawTag(65);
+ output.WriteFixed64(OptionalFixed64);
+ }
+ if (HasOptionalSfixed32) {
+ output.WriteRawTag(77);
+ output.WriteSFixed32(OptionalSfixed32);
+ }
+ if (HasOptionalSfixed64) {
+ output.WriteRawTag(81);
+ output.WriteSFixed64(OptionalSfixed64);
+ }
+ if (HasOptionalFloat) {
+ output.WriteRawTag(93);
+ output.WriteFloat(OptionalFloat);
+ }
+ if (HasOptionalDouble) {
+ output.WriteRawTag(97);
+ output.WriteDouble(OptionalDouble);
+ }
+ if (HasOptionalBool) {
+ output.WriteRawTag(104);
+ output.WriteBool(OptionalBool);
+ }
+ if (HasOptionalString) {
+ output.WriteRawTag(114);
+ output.WriteString(OptionalString);
+ }
+ if (HasOptionalBytes) {
+ output.WriteRawTag(122);
+ output.WriteBytes(OptionalBytes);
+ }
+ if (optionalNestedMessage_ != null) {
+ output.WriteRawTag(146, 1);
+ output.WriteMessage(OptionalNestedMessage);
+ }
+ if (optionalForeignMessage_ != null) {
+ output.WriteRawTag(154, 1);
+ output.WriteMessage(OptionalForeignMessage);
+ }
+ if (HasOptionalNestedEnum) {
+ output.WriteRawTag(168, 1);
+ output.WriteEnum((int) OptionalNestedEnum);
+ }
+ if (HasOptionalForeignEnum) {
+ output.WriteRawTag(176, 1);
+ output.WriteEnum((int) OptionalForeignEnum);
+ }
+ if (HasOptionalStringPiece) {
+ output.WriteRawTag(194, 1);
+ output.WriteString(OptionalStringPiece);
+ }
+ if (HasOptionalCord) {
+ output.WriteRawTag(202, 1);
+ output.WriteString(OptionalCord);
+ }
+ if (recursiveMessage_ != null) {
+ output.WriteRawTag(218, 1);
+ output.WriteMessage(RecursiveMessage);
+ }
+ repeatedInt32_.WriteTo(ref output, _repeated_repeatedInt32_codec);
+ repeatedInt64_.WriteTo(ref output, _repeated_repeatedInt64_codec);
+ repeatedUint32_.WriteTo(ref output, _repeated_repeatedUint32_codec);
+ repeatedUint64_.WriteTo(ref output, _repeated_repeatedUint64_codec);
+ repeatedSint32_.WriteTo(ref output, _repeated_repeatedSint32_codec);
+ repeatedSint64_.WriteTo(ref output, _repeated_repeatedSint64_codec);
+ repeatedFixed32_.WriteTo(ref output, _repeated_repeatedFixed32_codec);
+ repeatedFixed64_.WriteTo(ref output, _repeated_repeatedFixed64_codec);
+ repeatedSfixed32_.WriteTo(ref output, _repeated_repeatedSfixed32_codec);
+ repeatedSfixed64_.WriteTo(ref output, _repeated_repeatedSfixed64_codec);
+ repeatedFloat_.WriteTo(ref output, _repeated_repeatedFloat_codec);
+ repeatedDouble_.WriteTo(ref output, _repeated_repeatedDouble_codec);
+ repeatedBool_.WriteTo(ref output, _repeated_repeatedBool_codec);
+ repeatedString_.WriteTo(ref output, _repeated_repeatedString_codec);
+ repeatedBytes_.WriteTo(ref output, _repeated_repeatedBytes_codec);
+ repeatedNestedMessage_.WriteTo(ref output, _repeated_repeatedNestedMessage_codec);
+ repeatedForeignMessage_.WriteTo(ref output, _repeated_repeatedForeignMessage_codec);
+ repeatedNestedEnum_.WriteTo(ref output, _repeated_repeatedNestedEnum_codec);
+ repeatedForeignEnum_.WriteTo(ref output, _repeated_repeatedForeignEnum_codec);
+ repeatedStringPiece_.WriteTo(ref output, _repeated_repeatedStringPiece_codec);
+ repeatedCord_.WriteTo(ref output, _repeated_repeatedCord_codec);
+ mapInt32Int32_.WriteTo(ref output, _map_mapInt32Int32_codec);
+ mapInt64Int64_.WriteTo(ref output, _map_mapInt64Int64_codec);
+ mapUint32Uint32_.WriteTo(ref output, _map_mapUint32Uint32_codec);
+ mapUint64Uint64_.WriteTo(ref output, _map_mapUint64Uint64_codec);
+ mapSint32Sint32_.WriteTo(ref output, _map_mapSint32Sint32_codec);
+ mapSint64Sint64_.WriteTo(ref output, _map_mapSint64Sint64_codec);
+ mapFixed32Fixed32_.WriteTo(ref output, _map_mapFixed32Fixed32_codec);
+ mapFixed64Fixed64_.WriteTo(ref output, _map_mapFixed64Fixed64_codec);
+ mapSfixed32Sfixed32_.WriteTo(ref output, _map_mapSfixed32Sfixed32_codec);
+ mapSfixed64Sfixed64_.WriteTo(ref output, _map_mapSfixed64Sfixed64_codec);
+ mapInt32Float_.WriteTo(ref output, _map_mapInt32Float_codec);
+ mapInt32Double_.WriteTo(ref output, _map_mapInt32Double_codec);
+ mapBoolBool_.WriteTo(ref output, _map_mapBoolBool_codec);
+ mapStringString_.WriteTo(ref output, _map_mapStringString_codec);
+ mapStringBytes_.WriteTo(ref output, _map_mapStringBytes_codec);
+ mapStringNestedMessage_.WriteTo(ref output, _map_mapStringNestedMessage_codec);
+ mapStringForeignMessage_.WriteTo(ref output, _map_mapStringForeignMessage_codec);
+ mapStringNestedEnum_.WriteTo(ref output, _map_mapStringNestedEnum_codec);
+ mapStringForeignEnum_.WriteTo(ref output, _map_mapStringForeignEnum_codec);
+ packedInt32_.WriteTo(ref output, _repeated_packedInt32_codec);
+ packedInt64_.WriteTo(ref output, _repeated_packedInt64_codec);
+ packedUint32_.WriteTo(ref output, _repeated_packedUint32_codec);
+ packedUint64_.WriteTo(ref output, _repeated_packedUint64_codec);
+ packedSint32_.WriteTo(ref output, _repeated_packedSint32_codec);
+ packedSint64_.WriteTo(ref output, _repeated_packedSint64_codec);
+ packedFixed32_.WriteTo(ref output, _repeated_packedFixed32_codec);
+ packedFixed64_.WriteTo(ref output, _repeated_packedFixed64_codec);
+ packedSfixed32_.WriteTo(ref output, _repeated_packedSfixed32_codec);
+ packedSfixed64_.WriteTo(ref output, _repeated_packedSfixed64_codec);
+ packedFloat_.WriteTo(ref output, _repeated_packedFloat_codec);
+ packedDouble_.WriteTo(ref output, _repeated_packedDouble_codec);
+ packedBool_.WriteTo(ref output, _repeated_packedBool_codec);
+ packedNestedEnum_.WriteTo(ref output, _repeated_packedNestedEnum_codec);
+ unpackedInt32_.WriteTo(ref output, _repeated_unpackedInt32_codec);
+ unpackedInt64_.WriteTo(ref output, _repeated_unpackedInt64_codec);
+ unpackedUint32_.WriteTo(ref output, _repeated_unpackedUint32_codec);
+ unpackedUint64_.WriteTo(ref output, _repeated_unpackedUint64_codec);
+ unpackedSint32_.WriteTo(ref output, _repeated_unpackedSint32_codec);
+ unpackedSint64_.WriteTo(ref output, _repeated_unpackedSint64_codec);
+ unpackedFixed32_.WriteTo(ref output, _repeated_unpackedFixed32_codec);
+ unpackedFixed64_.WriteTo(ref output, _repeated_unpackedFixed64_codec);
+ unpackedSfixed32_.WriteTo(ref output, _repeated_unpackedSfixed32_codec);
+ unpackedSfixed64_.WriteTo(ref output, _repeated_unpackedSfixed64_codec);
+ unpackedFloat_.WriteTo(ref output, _repeated_unpackedFloat_codec);
+ unpackedDouble_.WriteTo(ref output, _repeated_unpackedDouble_codec);
+ unpackedBool_.WriteTo(ref output, _repeated_unpackedBool_codec);
+ unpackedNestedEnum_.WriteTo(ref output, _repeated_unpackedNestedEnum_codec);
+ if (HasOneofUint32) {
+ output.WriteRawTag(248, 6);
+ output.WriteUInt32(OneofUint32);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage) {
+ output.WriteRawTag(130, 7);
+ output.WriteMessage(OneofNestedMessage);
+ }
+ if (HasOneofString) {
+ output.WriteRawTag(138, 7);
+ output.WriteString(OneofString);
+ }
+ if (HasOneofBytes) {
+ output.WriteRawTag(146, 7);
+ output.WriteBytes(OneofBytes);
+ }
+ if (HasOneofBool) {
+ output.WriteRawTag(152, 7);
+ output.WriteBool(OneofBool);
+ }
+ if (HasOneofUint64) {
+ output.WriteRawTag(160, 7);
+ output.WriteUInt64(OneofUint64);
+ }
+ if (HasOneofFloat) {
+ output.WriteRawTag(173, 7);
+ output.WriteFloat(OneofFloat);
+ }
+ if (HasOneofDouble) {
+ output.WriteRawTag(177, 7);
+ output.WriteDouble(OneofDouble);
+ }
+ if (HasOneofEnum) {
+ output.WriteRawTag(184, 7);
+ output.WriteEnum((int) OneofEnum);
+ }
+ if (HasData) {
+ output.WriteRawTag(203, 12);
+ output.WriteGroup(Data);
+ output.WriteRawTag(204, 12);
+ }
+ if (HasFieldname1) {
+ output.WriteRawTag(136, 25);
+ output.WriteInt32(Fieldname1);
+ }
+ if (HasFieldName2) {
+ output.WriteRawTag(144, 25);
+ output.WriteInt32(FieldName2);
+ }
+ if (HasFieldName3) {
+ output.WriteRawTag(152, 25);
+ output.WriteInt32(FieldName3);
+ }
+ if (HasFieldName4) {
+ output.WriteRawTag(160, 25);
+ output.WriteInt32(FieldName4);
+ }
+ if (HasField0Name5) {
+ output.WriteRawTag(168, 25);
+ output.WriteInt32(Field0Name5);
+ }
+ if (HasField0Name6) {
+ output.WriteRawTag(176, 25);
+ output.WriteInt32(Field0Name6);
+ }
+ if (HasFieldName7) {
+ output.WriteRawTag(184, 25);
+ output.WriteInt32(FieldName7);
+ }
+ if (HasFieldName8) {
+ output.WriteRawTag(192, 25);
+ output.WriteInt32(FieldName8);
+ }
+ if (HasFieldName9) {
+ output.WriteRawTag(200, 25);
+ output.WriteInt32(FieldName9);
+ }
+ if (HasFieldName10) {
+ output.WriteRawTag(208, 25);
+ output.WriteInt32(FieldName10);
+ }
+ if (HasFIELDNAME11) {
+ output.WriteRawTag(216, 25);
+ output.WriteInt32(FIELDNAME11);
+ }
+ if (HasFIELDName12) {
+ output.WriteRawTag(224, 25);
+ output.WriteInt32(FIELDName12);
+ }
+ if (HasFieldName13) {
+ output.WriteRawTag(232, 25);
+ output.WriteInt32(FieldName13);
+ }
+ if (HasFieldName14) {
+ output.WriteRawTag(240, 25);
+ output.WriteInt32(FieldName14);
+ }
+ if (HasFieldName15) {
+ output.WriteRawTag(248, 25);
+ output.WriteInt32(FieldName15);
+ }
+ if (HasFieldName16) {
+ output.WriteRawTag(128, 26);
+ output.WriteInt32(FieldName16);
+ }
+ if (HasFieldName17) {
+ output.WriteRawTag(136, 26);
+ output.WriteInt32(FieldName17);
+ }
+ if (HasFieldName18) {
+ output.WriteRawTag(144, 26);
+ output.WriteInt32(FieldName18);
+ }
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -4561,6 +4846,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(8);
output.WriteInt32(A);
@@ -4572,8 +4860,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(8);
+ output.WriteInt32(A);
+ }
+ if (corecursive_ != null) {
+ output.WriteRawTag(18);
+ output.WriteMessage(Corecursive);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -4788,6 +5094,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasGroupInt32) {
output.WriteRawTag(208, 12);
output.WriteInt32(GroupInt32);
@@ -4799,8 +5108,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasGroupInt32) {
+ output.WriteRawTag(208, 12);
+ output.WriteInt32(GroupInt32);
+ }
+ if (HasGroupUint32) {
+ output.WriteRawTag(216, 12);
+ output.WriteUInt32(GroupUint32);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -4963,13 +5290,29 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_extensions != null) {
_extensions.WriteTo(output);
}
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5145,6 +5488,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasStr) {
output.WriteRawTag(202, 1);
output.WriteString(Str);
@@ -5152,7 +5498,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasStr) {
+ output.WriteRawTag(202, 1);
+ output.WriteString(Str);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5324,6 +5684,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasI) {
output.WriteRawTag(72);
output.WriteInt32(I);
@@ -5331,7 +5694,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasI) {
+ output.WriteRawTag(72);
+ output.WriteInt32(I);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5508,6 +5885,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasC) {
output.WriteRawTag(8);
output.WriteInt32(C);
@@ -5515,7 +5895,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasC) {
+ output.WriteRawTag(8);
+ output.WriteInt32(C);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5782,6 +6176,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasOptionalInt32) {
output.WriteRawTag(200, 62);
output.WriteInt32(OptionalInt32);
@@ -5807,8 +6204,40 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasOptionalInt32) {
+ output.WriteRawTag(200, 62);
+ output.WriteInt32(OptionalInt32);
+ }
+ if (HasOptionalString) {
+ output.WriteRawTag(210, 62);
+ output.WriteString(OptionalString);
+ }
+ if (nestedMessage_ != null) {
+ output.WriteRawTag(218, 62);
+ output.WriteMessage(NestedMessage);
+ }
+ if (HasOptionalGroup) {
+ output.WriteRawTag(227, 62);
+ output.WriteGroup(OptionalGroup);
+ output.WriteRawTag(228, 62);
+ }
+ if (HasOptionalBool) {
+ output.WriteRawTag(240, 62);
+ output.WriteBool(OptionalBool);
+ }
+ repeatedInt32_.WriteTo(ref output, _repeated_repeatedInt32_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -6058,6 +6487,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(8);
output.WriteInt32(A);
@@ -6065,8 +6497,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(8);
+ output.WriteInt32(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/TestMessagesProto3.cs b/csharp/src/Google.Protobuf.Test.TestProtos/TestMessagesProto3.cs
index 41bc006cb162..1d49f4c03f2a 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/TestMessagesProto3.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/TestMessagesProto3.cs
@@ -2419,6 +2419,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (OptionalInt32 != 0) {
output.WriteRawTag(8);
output.WriteInt32(OptionalInt32);
@@ -2757,8 +2760,353 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (OptionalInt32 != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(OptionalInt32);
+ }
+ if (OptionalInt64 != 0L) {
+ output.WriteRawTag(16);
+ output.WriteInt64(OptionalInt64);
+ }
+ if (OptionalUint32 != 0) {
+ output.WriteRawTag(24);
+ output.WriteUInt32(OptionalUint32);
+ }
+ if (OptionalUint64 != 0UL) {
+ output.WriteRawTag(32);
+ output.WriteUInt64(OptionalUint64);
+ }
+ if (OptionalSint32 != 0) {
+ output.WriteRawTag(40);
+ output.WriteSInt32(OptionalSint32);
+ }
+ if (OptionalSint64 != 0L) {
+ output.WriteRawTag(48);
+ output.WriteSInt64(OptionalSint64);
+ }
+ if (OptionalFixed32 != 0) {
+ output.WriteRawTag(61);
+ output.WriteFixed32(OptionalFixed32);
+ }
+ if (OptionalFixed64 != 0UL) {
+ output.WriteRawTag(65);
+ output.WriteFixed64(OptionalFixed64);
+ }
+ if (OptionalSfixed32 != 0) {
+ output.WriteRawTag(77);
+ output.WriteSFixed32(OptionalSfixed32);
+ }
+ if (OptionalSfixed64 != 0L) {
+ output.WriteRawTag(81);
+ output.WriteSFixed64(OptionalSfixed64);
+ }
+ if (OptionalFloat != 0F) {
+ output.WriteRawTag(93);
+ output.WriteFloat(OptionalFloat);
+ }
+ if (OptionalDouble != 0D) {
+ output.WriteRawTag(97);
+ output.WriteDouble(OptionalDouble);
+ }
+ if (OptionalBool != false) {
+ output.WriteRawTag(104);
+ output.WriteBool(OptionalBool);
+ }
+ if (OptionalString.Length != 0) {
+ output.WriteRawTag(114);
+ output.WriteString(OptionalString);
+ }
+ if (OptionalBytes.Length != 0) {
+ output.WriteRawTag(122);
+ output.WriteBytes(OptionalBytes);
+ }
+ if (optionalNestedMessage_ != null) {
+ output.WriteRawTag(146, 1);
+ output.WriteMessage(OptionalNestedMessage);
+ }
+ if (optionalForeignMessage_ != null) {
+ output.WriteRawTag(154, 1);
+ output.WriteMessage(OptionalForeignMessage);
+ }
+ if (OptionalNestedEnum != global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.NestedEnum.Foo) {
+ output.WriteRawTag(168, 1);
+ output.WriteEnum((int) OptionalNestedEnum);
+ }
+ if (OptionalForeignEnum != global::ProtobufTestMessages.Proto3.ForeignEnum.ForeignFoo) {
+ output.WriteRawTag(176, 1);
+ output.WriteEnum((int) OptionalForeignEnum);
+ }
+ if (OptionalAliasedEnum != global::ProtobufTestMessages.Proto3.TestAllTypesProto3.Types.AliasedEnum.AliasFoo) {
+ output.WriteRawTag(184, 1);
+ output.WriteEnum((int) OptionalAliasedEnum);
+ }
+ if (OptionalStringPiece.Length != 0) {
+ output.WriteRawTag(194, 1);
+ output.WriteString(OptionalStringPiece);
+ }
+ if (OptionalCord.Length != 0) {
+ output.WriteRawTag(202, 1);
+ output.WriteString(OptionalCord);
+ }
+ if (recursiveMessage_ != null) {
+ output.WriteRawTag(218, 1);
+ output.WriteMessage(RecursiveMessage);
+ }
+ repeatedInt32_.WriteTo(ref output, _repeated_repeatedInt32_codec);
+ repeatedInt64_.WriteTo(ref output, _repeated_repeatedInt64_codec);
+ repeatedUint32_.WriteTo(ref output, _repeated_repeatedUint32_codec);
+ repeatedUint64_.WriteTo(ref output, _repeated_repeatedUint64_codec);
+ repeatedSint32_.WriteTo(ref output, _repeated_repeatedSint32_codec);
+ repeatedSint64_.WriteTo(ref output, _repeated_repeatedSint64_codec);
+ repeatedFixed32_.WriteTo(ref output, _repeated_repeatedFixed32_codec);
+ repeatedFixed64_.WriteTo(ref output, _repeated_repeatedFixed64_codec);
+ repeatedSfixed32_.WriteTo(ref output, _repeated_repeatedSfixed32_codec);
+ repeatedSfixed64_.WriteTo(ref output, _repeated_repeatedSfixed64_codec);
+ repeatedFloat_.WriteTo(ref output, _repeated_repeatedFloat_codec);
+ repeatedDouble_.WriteTo(ref output, _repeated_repeatedDouble_codec);
+ repeatedBool_.WriteTo(ref output, _repeated_repeatedBool_codec);
+ repeatedString_.WriteTo(ref output, _repeated_repeatedString_codec);
+ repeatedBytes_.WriteTo(ref output, _repeated_repeatedBytes_codec);
+ repeatedNestedMessage_.WriteTo(ref output, _repeated_repeatedNestedMessage_codec);
+ repeatedForeignMessage_.WriteTo(ref output, _repeated_repeatedForeignMessage_codec);
+ repeatedNestedEnum_.WriteTo(ref output, _repeated_repeatedNestedEnum_codec);
+ repeatedForeignEnum_.WriteTo(ref output, _repeated_repeatedForeignEnum_codec);
+ repeatedStringPiece_.WriteTo(ref output, _repeated_repeatedStringPiece_codec);
+ repeatedCord_.WriteTo(ref output, _repeated_repeatedCord_codec);
+ mapInt32Int32_.WriteTo(ref output, _map_mapInt32Int32_codec);
+ mapInt64Int64_.WriteTo(ref output, _map_mapInt64Int64_codec);
+ mapUint32Uint32_.WriteTo(ref output, _map_mapUint32Uint32_codec);
+ mapUint64Uint64_.WriteTo(ref output, _map_mapUint64Uint64_codec);
+ mapSint32Sint32_.WriteTo(ref output, _map_mapSint32Sint32_codec);
+ mapSint64Sint64_.WriteTo(ref output, _map_mapSint64Sint64_codec);
+ mapFixed32Fixed32_.WriteTo(ref output, _map_mapFixed32Fixed32_codec);
+ mapFixed64Fixed64_.WriteTo(ref output, _map_mapFixed64Fixed64_codec);
+ mapSfixed32Sfixed32_.WriteTo(ref output, _map_mapSfixed32Sfixed32_codec);
+ mapSfixed64Sfixed64_.WriteTo(ref output, _map_mapSfixed64Sfixed64_codec);
+ mapInt32Float_.WriteTo(ref output, _map_mapInt32Float_codec);
+ mapInt32Double_.WriteTo(ref output, _map_mapInt32Double_codec);
+ mapBoolBool_.WriteTo(ref output, _map_mapBoolBool_codec);
+ mapStringString_.WriteTo(ref output, _map_mapStringString_codec);
+ mapStringBytes_.WriteTo(ref output, _map_mapStringBytes_codec);
+ mapStringNestedMessage_.WriteTo(ref output, _map_mapStringNestedMessage_codec);
+ mapStringForeignMessage_.WriteTo(ref output, _map_mapStringForeignMessage_codec);
+ mapStringNestedEnum_.WriteTo(ref output, _map_mapStringNestedEnum_codec);
+ mapStringForeignEnum_.WriteTo(ref output, _map_mapStringForeignEnum_codec);
+ packedInt32_.WriteTo(ref output, _repeated_packedInt32_codec);
+ packedInt64_.WriteTo(ref output, _repeated_packedInt64_codec);
+ packedUint32_.WriteTo(ref output, _repeated_packedUint32_codec);
+ packedUint64_.WriteTo(ref output, _repeated_packedUint64_codec);
+ packedSint32_.WriteTo(ref output, _repeated_packedSint32_codec);
+ packedSint64_.WriteTo(ref output, _repeated_packedSint64_codec);
+ packedFixed32_.WriteTo(ref output, _repeated_packedFixed32_codec);
+ packedFixed64_.WriteTo(ref output, _repeated_packedFixed64_codec);
+ packedSfixed32_.WriteTo(ref output, _repeated_packedSfixed32_codec);
+ packedSfixed64_.WriteTo(ref output, _repeated_packedSfixed64_codec);
+ packedFloat_.WriteTo(ref output, _repeated_packedFloat_codec);
+ packedDouble_.WriteTo(ref output, _repeated_packedDouble_codec);
+ packedBool_.WriteTo(ref output, _repeated_packedBool_codec);
+ packedNestedEnum_.WriteTo(ref output, _repeated_packedNestedEnum_codec);
+ unpackedInt32_.WriteTo(ref output, _repeated_unpackedInt32_codec);
+ unpackedInt64_.WriteTo(ref output, _repeated_unpackedInt64_codec);
+ unpackedUint32_.WriteTo(ref output, _repeated_unpackedUint32_codec);
+ unpackedUint64_.WriteTo(ref output, _repeated_unpackedUint64_codec);
+ unpackedSint32_.WriteTo(ref output, _repeated_unpackedSint32_codec);
+ unpackedSint64_.WriteTo(ref output, _repeated_unpackedSint64_codec);
+ unpackedFixed32_.WriteTo(ref output, _repeated_unpackedFixed32_codec);
+ unpackedFixed64_.WriteTo(ref output, _repeated_unpackedFixed64_codec);
+ unpackedSfixed32_.WriteTo(ref output, _repeated_unpackedSfixed32_codec);
+ unpackedSfixed64_.WriteTo(ref output, _repeated_unpackedSfixed64_codec);
+ unpackedFloat_.WriteTo(ref output, _repeated_unpackedFloat_codec);
+ unpackedDouble_.WriteTo(ref output, _repeated_unpackedDouble_codec);
+ unpackedBool_.WriteTo(ref output, _repeated_unpackedBool_codec);
+ unpackedNestedEnum_.WriteTo(ref output, _repeated_unpackedNestedEnum_codec);
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) {
+ output.WriteRawTag(248, 6);
+ output.WriteUInt32(OneofUint32);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage) {
+ output.WriteRawTag(130, 7);
+ output.WriteMessage(OneofNestedMessage);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofString) {
+ output.WriteRawTag(138, 7);
+ output.WriteString(OneofString);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofBytes) {
+ output.WriteRawTag(146, 7);
+ output.WriteBytes(OneofBytes);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofBool) {
+ output.WriteRawTag(152, 7);
+ output.WriteBool(OneofBool);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint64) {
+ output.WriteRawTag(160, 7);
+ output.WriteUInt64(OneofUint64);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofFloat) {
+ output.WriteRawTag(173, 7);
+ output.WriteFloat(OneofFloat);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofDouble) {
+ output.WriteRawTag(177, 7);
+ output.WriteDouble(OneofDouble);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofEnum) {
+ output.WriteRawTag(184, 7);
+ output.WriteEnum((int) OneofEnum);
+ }
+ if (optionalBoolWrapper_ != null) {
+ _single_optionalBoolWrapper_codec.WriteTagAndValue(ref output, OptionalBoolWrapper);
+ }
+ if (optionalInt32Wrapper_ != null) {
+ _single_optionalInt32Wrapper_codec.WriteTagAndValue(ref output, OptionalInt32Wrapper);
+ }
+ if (optionalInt64Wrapper_ != null) {
+ _single_optionalInt64Wrapper_codec.WriteTagAndValue(ref output, OptionalInt64Wrapper);
+ }
+ if (optionalUint32Wrapper_ != null) {
+ _single_optionalUint32Wrapper_codec.WriteTagAndValue(ref output, OptionalUint32Wrapper);
+ }
+ if (optionalUint64Wrapper_ != null) {
+ _single_optionalUint64Wrapper_codec.WriteTagAndValue(ref output, OptionalUint64Wrapper);
+ }
+ if (optionalFloatWrapper_ != null) {
+ _single_optionalFloatWrapper_codec.WriteTagAndValue(ref output, OptionalFloatWrapper);
+ }
+ if (optionalDoubleWrapper_ != null) {
+ _single_optionalDoubleWrapper_codec.WriteTagAndValue(ref output, OptionalDoubleWrapper);
+ }
+ if (optionalStringWrapper_ != null) {
+ _single_optionalStringWrapper_codec.WriteTagAndValue(ref output, OptionalStringWrapper);
+ }
+ if (optionalBytesWrapper_ != null) {
+ _single_optionalBytesWrapper_codec.WriteTagAndValue(ref output, OptionalBytesWrapper);
+ }
+ repeatedBoolWrapper_.WriteTo(ref output, _repeated_repeatedBoolWrapper_codec);
+ repeatedInt32Wrapper_.WriteTo(ref output, _repeated_repeatedInt32Wrapper_codec);
+ repeatedInt64Wrapper_.WriteTo(ref output, _repeated_repeatedInt64Wrapper_codec);
+ repeatedUint32Wrapper_.WriteTo(ref output, _repeated_repeatedUint32Wrapper_codec);
+ repeatedUint64Wrapper_.WriteTo(ref output, _repeated_repeatedUint64Wrapper_codec);
+ repeatedFloatWrapper_.WriteTo(ref output, _repeated_repeatedFloatWrapper_codec);
+ repeatedDoubleWrapper_.WriteTo(ref output, _repeated_repeatedDoubleWrapper_codec);
+ repeatedStringWrapper_.WriteTo(ref output, _repeated_repeatedStringWrapper_codec);
+ repeatedBytesWrapper_.WriteTo(ref output, _repeated_repeatedBytesWrapper_codec);
+ if (optionalDuration_ != null) {
+ output.WriteRawTag(234, 18);
+ output.WriteMessage(OptionalDuration);
+ }
+ if (optionalTimestamp_ != null) {
+ output.WriteRawTag(242, 18);
+ output.WriteMessage(OptionalTimestamp);
+ }
+ if (optionalFieldMask_ != null) {
+ output.WriteRawTag(250, 18);
+ output.WriteMessage(OptionalFieldMask);
+ }
+ if (optionalStruct_ != null) {
+ output.WriteRawTag(130, 19);
+ output.WriteMessage(OptionalStruct);
+ }
+ if (optionalAny_ != null) {
+ output.WriteRawTag(138, 19);
+ output.WriteMessage(OptionalAny);
+ }
+ if (optionalValue_ != null) {
+ output.WriteRawTag(146, 19);
+ output.WriteMessage(OptionalValue);
+ }
+ repeatedDuration_.WriteTo(ref output, _repeated_repeatedDuration_codec);
+ repeatedTimestamp_.WriteTo(ref output, _repeated_repeatedTimestamp_codec);
+ repeatedFieldmask_.WriteTo(ref output, _repeated_repeatedFieldmask_codec);
+ repeatedAny_.WriteTo(ref output, _repeated_repeatedAny_codec);
+ repeatedValue_.WriteTo(ref output, _repeated_repeatedValue_codec);
+ repeatedListValue_.WriteTo(ref output, _repeated_repeatedListValue_codec);
+ repeatedStruct_.WriteTo(ref output, _repeated_repeatedStruct_codec);
+ if (Fieldname1 != 0) {
+ output.WriteRawTag(136, 25);
+ output.WriteInt32(Fieldname1);
+ }
+ if (FieldName2 != 0) {
+ output.WriteRawTag(144, 25);
+ output.WriteInt32(FieldName2);
+ }
+ if (FieldName3 != 0) {
+ output.WriteRawTag(152, 25);
+ output.WriteInt32(FieldName3);
+ }
+ if (FieldName4 != 0) {
+ output.WriteRawTag(160, 25);
+ output.WriteInt32(FieldName4);
+ }
+ if (Field0Name5 != 0) {
+ output.WriteRawTag(168, 25);
+ output.WriteInt32(Field0Name5);
+ }
+ if (Field0Name6 != 0) {
+ output.WriteRawTag(176, 25);
+ output.WriteInt32(Field0Name6);
+ }
+ if (FieldName7 != 0) {
+ output.WriteRawTag(184, 25);
+ output.WriteInt32(FieldName7);
+ }
+ if (FieldName8 != 0) {
+ output.WriteRawTag(192, 25);
+ output.WriteInt32(FieldName8);
+ }
+ if (FieldName9 != 0) {
+ output.WriteRawTag(200, 25);
+ output.WriteInt32(FieldName9);
+ }
+ if (FieldName10 != 0) {
+ output.WriteRawTag(208, 25);
+ output.WriteInt32(FieldName10);
+ }
+ if (FIELDNAME11 != 0) {
+ output.WriteRawTag(216, 25);
+ output.WriteInt32(FIELDNAME11);
+ }
+ if (FIELDName12 != 0) {
+ output.WriteRawTag(224, 25);
+ output.WriteInt32(FIELDName12);
+ }
+ if (FieldName13 != 0) {
+ output.WriteRawTag(232, 25);
+ output.WriteInt32(FieldName13);
+ }
+ if (FieldName14 != 0) {
+ output.WriteRawTag(240, 25);
+ output.WriteInt32(FieldName14);
+ }
+ if (FieldName15 != 0) {
+ output.WriteRawTag(248, 25);
+ output.WriteInt32(FieldName15);
+ }
+ if (FieldName16 != 0) {
+ output.WriteRawTag(128, 26);
+ output.WriteInt32(FieldName16);
+ }
+ if (FieldName17 != 0) {
+ output.WriteRawTag(136, 26);
+ output.WriteInt32(FieldName17);
+ }
+ if (FieldName18 != 0) {
+ output.WriteRawTag(144, 26);
+ output.WriteInt32(FieldName18);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -4933,6 +5281,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (A != 0) {
output.WriteRawTag(8);
output.WriteInt32(A);
@@ -4944,8 +5295,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (A != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(A);
+ }
+ if (corecursive_ != null) {
+ output.WriteRawTag(18);
+ output.WriteMessage(Corecursive);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -5120,6 +5489,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (C != 0) {
output.WriteRawTag(8);
output.WriteInt32(C);
@@ -5127,8 +5499,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (C != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(C);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/Unittest.cs b/csharp/src/Google.Protobuf.Test.TestProtos/Unittest.cs
index 373f569df32c..a843c4ae8baf 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/Unittest.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/Unittest.cs
@@ -2822,6 +2822,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasOptionalInt32) {
output.WriteRawTag(8);
output.WriteInt32(OptionalInt32);
@@ -3051,7 +3054,243 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasOptionalInt32) {
+ output.WriteRawTag(8);
+ output.WriteInt32(OptionalInt32);
+ }
+ if (HasOptionalInt64) {
+ output.WriteRawTag(16);
+ output.WriteInt64(OptionalInt64);
+ }
+ if (HasOptionalUint32) {
+ output.WriteRawTag(24);
+ output.WriteUInt32(OptionalUint32);
+ }
+ if (HasOptionalUint64) {
+ output.WriteRawTag(32);
+ output.WriteUInt64(OptionalUint64);
+ }
+ if (HasOptionalSint32) {
+ output.WriteRawTag(40);
+ output.WriteSInt32(OptionalSint32);
+ }
+ if (HasOptionalSint64) {
+ output.WriteRawTag(48);
+ output.WriteSInt64(OptionalSint64);
+ }
+ if (HasOptionalFixed32) {
+ output.WriteRawTag(61);
+ output.WriteFixed32(OptionalFixed32);
+ }
+ if (HasOptionalFixed64) {
+ output.WriteRawTag(65);
+ output.WriteFixed64(OptionalFixed64);
+ }
+ if (HasOptionalSfixed32) {
+ output.WriteRawTag(77);
+ output.WriteSFixed32(OptionalSfixed32);
+ }
+ if (HasOptionalSfixed64) {
+ output.WriteRawTag(81);
+ output.WriteSFixed64(OptionalSfixed64);
+ }
+ if (HasOptionalFloat) {
+ output.WriteRawTag(93);
+ output.WriteFloat(OptionalFloat);
+ }
+ if (HasOptionalDouble) {
+ output.WriteRawTag(97);
+ output.WriteDouble(OptionalDouble);
+ }
+ if (HasOptionalBool) {
+ output.WriteRawTag(104);
+ output.WriteBool(OptionalBool);
+ }
+ if (HasOptionalString) {
+ output.WriteRawTag(114);
+ output.WriteString(OptionalString);
+ }
+ if (HasOptionalBytes) {
+ output.WriteRawTag(122);
+ output.WriteBytes(OptionalBytes);
+ }
+ if (HasOptionalGroup) {
+ output.WriteRawTag(131, 1);
+ output.WriteGroup(OptionalGroup);
+ output.WriteRawTag(132, 1);
+ }
+ if (optionalNestedMessage_ != null) {
+ output.WriteRawTag(146, 1);
+ output.WriteMessage(OptionalNestedMessage);
+ }
+ if (optionalForeignMessage_ != null) {
+ output.WriteRawTag(154, 1);
+ output.WriteMessage(OptionalForeignMessage);
+ }
+ if (optionalImportMessage_ != null) {
+ output.WriteRawTag(162, 1);
+ output.WriteMessage(OptionalImportMessage);
+ }
+ if (HasOptionalNestedEnum) {
+ output.WriteRawTag(168, 1);
+ output.WriteEnum((int) OptionalNestedEnum);
+ }
+ if (HasOptionalForeignEnum) {
+ output.WriteRawTag(176, 1);
+ output.WriteEnum((int) OptionalForeignEnum);
+ }
+ if (HasOptionalImportEnum) {
+ output.WriteRawTag(184, 1);
+ output.WriteEnum((int) OptionalImportEnum);
+ }
+ if (HasOptionalStringPiece) {
+ output.WriteRawTag(194, 1);
+ output.WriteString(OptionalStringPiece);
+ }
+ if (HasOptionalCord) {
+ output.WriteRawTag(202, 1);
+ output.WriteString(OptionalCord);
+ }
+ if (optionalPublicImportMessage_ != null) {
+ output.WriteRawTag(210, 1);
+ output.WriteMessage(OptionalPublicImportMessage);
+ }
+ if (optionalLazyMessage_ != null) {
+ output.WriteRawTag(218, 1);
+ output.WriteMessage(OptionalLazyMessage);
+ }
+ repeatedInt32_.WriteTo(ref output, _repeated_repeatedInt32_codec);
+ repeatedInt64_.WriteTo(ref output, _repeated_repeatedInt64_codec);
+ repeatedUint32_.WriteTo(ref output, _repeated_repeatedUint32_codec);
+ repeatedUint64_.WriteTo(ref output, _repeated_repeatedUint64_codec);
+ repeatedSint32_.WriteTo(ref output, _repeated_repeatedSint32_codec);
+ repeatedSint64_.WriteTo(ref output, _repeated_repeatedSint64_codec);
+ repeatedFixed32_.WriteTo(ref output, _repeated_repeatedFixed32_codec);
+ repeatedFixed64_.WriteTo(ref output, _repeated_repeatedFixed64_codec);
+ repeatedSfixed32_.WriteTo(ref output, _repeated_repeatedSfixed32_codec);
+ repeatedSfixed64_.WriteTo(ref output, _repeated_repeatedSfixed64_codec);
+ repeatedFloat_.WriteTo(ref output, _repeated_repeatedFloat_codec);
+ repeatedDouble_.WriteTo(ref output, _repeated_repeatedDouble_codec);
+ repeatedBool_.WriteTo(ref output, _repeated_repeatedBool_codec);
+ repeatedString_.WriteTo(ref output, _repeated_repeatedString_codec);
+ repeatedBytes_.WriteTo(ref output, _repeated_repeatedBytes_codec);
+ repeatedGroup_.WriteTo(ref output, _repeated_repeatedGroup_codec);
+ repeatedNestedMessage_.WriteTo(ref output, _repeated_repeatedNestedMessage_codec);
+ repeatedForeignMessage_.WriteTo(ref output, _repeated_repeatedForeignMessage_codec);
+ repeatedImportMessage_.WriteTo(ref output, _repeated_repeatedImportMessage_codec);
+ repeatedNestedEnum_.WriteTo(ref output, _repeated_repeatedNestedEnum_codec);
+ repeatedForeignEnum_.WriteTo(ref output, _repeated_repeatedForeignEnum_codec);
+ repeatedImportEnum_.WriteTo(ref output, _repeated_repeatedImportEnum_codec);
+ repeatedStringPiece_.WriteTo(ref output, _repeated_repeatedStringPiece_codec);
+ repeatedCord_.WriteTo(ref output, _repeated_repeatedCord_codec);
+ repeatedLazyMessage_.WriteTo(ref output, _repeated_repeatedLazyMessage_codec);
+ if (HasDefaultInt32) {
+ output.WriteRawTag(232, 3);
+ output.WriteInt32(DefaultInt32);
+ }
+ if (HasDefaultInt64) {
+ output.WriteRawTag(240, 3);
+ output.WriteInt64(DefaultInt64);
+ }
+ if (HasDefaultUint32) {
+ output.WriteRawTag(248, 3);
+ output.WriteUInt32(DefaultUint32);
+ }
+ if (HasDefaultUint64) {
+ output.WriteRawTag(128, 4);
+ output.WriteUInt64(DefaultUint64);
+ }
+ if (HasDefaultSint32) {
+ output.WriteRawTag(136, 4);
+ output.WriteSInt32(DefaultSint32);
+ }
+ if (HasDefaultSint64) {
+ output.WriteRawTag(144, 4);
+ output.WriteSInt64(DefaultSint64);
+ }
+ if (HasDefaultFixed32) {
+ output.WriteRawTag(157, 4);
+ output.WriteFixed32(DefaultFixed32);
+ }
+ if (HasDefaultFixed64) {
+ output.WriteRawTag(161, 4);
+ output.WriteFixed64(DefaultFixed64);
+ }
+ if (HasDefaultSfixed32) {
+ output.WriteRawTag(173, 4);
+ output.WriteSFixed32(DefaultSfixed32);
+ }
+ if (HasDefaultSfixed64) {
+ output.WriteRawTag(177, 4);
+ output.WriteSFixed64(DefaultSfixed64);
+ }
+ if (HasDefaultFloat) {
+ output.WriteRawTag(189, 4);
+ output.WriteFloat(DefaultFloat);
+ }
+ if (HasDefaultDouble) {
+ output.WriteRawTag(193, 4);
+ output.WriteDouble(DefaultDouble);
+ }
+ if (HasDefaultBool) {
+ output.WriteRawTag(200, 4);
+ output.WriteBool(DefaultBool);
+ }
+ if (HasDefaultString) {
+ output.WriteRawTag(210, 4);
+ output.WriteString(DefaultString);
+ }
+ if (HasDefaultBytes) {
+ output.WriteRawTag(218, 4);
+ output.WriteBytes(DefaultBytes);
+ }
+ if (HasDefaultNestedEnum) {
+ output.WriteRawTag(136, 5);
+ output.WriteEnum((int) DefaultNestedEnum);
+ }
+ if (HasDefaultForeignEnum) {
+ output.WriteRawTag(144, 5);
+ output.WriteEnum((int) DefaultForeignEnum);
+ }
+ if (HasDefaultImportEnum) {
+ output.WriteRawTag(152, 5);
+ output.WriteEnum((int) DefaultImportEnum);
+ }
+ if (HasDefaultStringPiece) {
+ output.WriteRawTag(162, 5);
+ output.WriteString(DefaultStringPiece);
+ }
+ if (HasDefaultCord) {
+ output.WriteRawTag(170, 5);
+ output.WriteString(DefaultCord);
+ }
+ if (HasOneofUint32) {
+ output.WriteRawTag(248, 6);
+ output.WriteUInt32(OneofUint32);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage) {
+ output.WriteRawTag(130, 7);
+ output.WriteMessage(OneofNestedMessage);
+ }
+ if (HasOneofString) {
+ output.WriteRawTag(138, 7);
+ output.WriteString(OneofString);
+ }
+ if (HasOneofBytes) {
+ output.WriteRawTag(146, 7);
+ output.WriteBytes(OneofBytes);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -4269,6 +4508,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasBb) {
output.WriteRawTag(8);
output.WriteInt32(Bb);
@@ -4276,7 +4518,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasBb) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Bb);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -4439,6 +4695,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(136, 1);
output.WriteInt32(A);
@@ -4446,7 +4705,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(136, 1);
+ output.WriteInt32(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -4613,6 +4886,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(248, 2);
output.WriteInt32(A);
@@ -4620,7 +4896,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(248, 2);
+ output.WriteInt32(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -4807,6 +5097,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (child_ != null) {
output.WriteRawTag(10);
output.WriteMessage(Child);
@@ -4819,8 +5112,27 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (child_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(Child);
+ }
+ if (payload_ != null) {
+ output.WriteRawTag(18);
+ output.WriteMessage(Payload);
+ }
+ repeatedChild_.WriteTo(ref output, _repeated_repeatedChild_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -5081,6 +5393,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasDeprecatedInt32) {
output.WriteRawTag(8);
output.WriteInt32(DeprecatedInt32);
@@ -5092,8 +5407,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasDeprecatedInt32) {
+ output.WriteRawTag(8);
+ output.WriteInt32(DeprecatedInt32);
+ }
+ if (HasDeprecatedInt32InOneof) {
+ output.WriteRawTag(16);
+ output.WriteInt32(DeprecatedInt32InOneof);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -5244,10 +5577,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5427,6 +5773,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasC) {
output.WriteRawTag(8);
output.WriteInt32(C);
@@ -5438,7 +5787,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasC) {
+ output.WriteRawTag(8);
+ output.WriteInt32(C);
+ }
+ if (HasD) {
+ output.WriteRawTag(16);
+ output.WriteInt32(D);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5586,10 +5953,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5718,14 +6098,30 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_extensions != null) {
_extensions.WriteTo(output);
}
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -5903,6 +6299,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(136, 1);
output.WriteInt32(A);
@@ -5910,7 +6309,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(136, 1);
+ output.WriteInt32(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6077,6 +6490,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(248, 2);
output.WriteInt32(A);
@@ -6084,8 +6500,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(248, 2);
+ output.WriteInt32(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -6275,6 +6705,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasOptionalGroup) {
output.WriteRawTag(131, 1);
output.WriteGroup(OptionalGroup);
@@ -6287,8 +6720,27 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasOptionalGroup) {
+ output.WriteRawTag(131, 1);
+ output.WriteGroup(OptionalGroup);
+ output.WriteRawTag(132, 1);
+ }
+ if (HasOptionalForeignEnum) {
+ output.WriteRawTag(176, 1);
+ output.WriteEnum((int) OptionalForeignEnum);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -6475,6 +6927,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(136, 1);
output.WriteInt32(A);
@@ -6482,7 +6937,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(136, 1);
+ output.WriteInt32(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6634,13 +7103,29 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_extensions != null) {
_extensions.WriteTo(output);
}
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6790,11 +7275,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -6944,6 +7442,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(136, 1);
output.WriteInt32(A);
@@ -6951,8 +7452,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(136, 1);
+ output.WriteInt32(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -7913,116 +8428,260 @@ public int C {
_hasBits1 |= 1;
c_ = value;
}
- }
- /// Gets whether the "c" field is set
- [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public bool HasC {
- get { return (_hasBits1 & 1) != 0; }
- }
- /// Clears the value of the "c" field
- [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public void ClearC() {
- _hasBits1 &= ~1;
- }
-
- [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public override bool Equals(object other) {
- return Equals(other as TestRequired);
- }
-
- [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public bool Equals(TestRequired other) {
- if (ReferenceEquals(other, null)) {
- return false;
+ }
+ /// Gets whether the "c" field is set
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ public bool HasC {
+ get { return (_hasBits1 & 1) != 0; }
+ }
+ /// Clears the value of the "c" field
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ public void ClearC() {
+ _hasBits1 &= ~1;
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ public override bool Equals(object other) {
+ return Equals(other as TestRequired);
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ public bool Equals(TestRequired other) {
+ if (ReferenceEquals(other, null)) {
+ return false;
+ }
+ if (ReferenceEquals(other, this)) {
+ return true;
+ }
+ if (A != other.A) return false;
+ if (Dummy2 != other.Dummy2) return false;
+ if (B != other.B) return false;
+ if (Dummy4 != other.Dummy4) return false;
+ if (Dummy5 != other.Dummy5) return false;
+ if (Dummy6 != other.Dummy6) return false;
+ if (Dummy7 != other.Dummy7) return false;
+ if (Dummy8 != other.Dummy8) return false;
+ if (Dummy9 != other.Dummy9) return false;
+ if (Dummy10 != other.Dummy10) return false;
+ if (Dummy11 != other.Dummy11) return false;
+ if (Dummy12 != other.Dummy12) return false;
+ if (Dummy13 != other.Dummy13) return false;
+ if (Dummy14 != other.Dummy14) return false;
+ if (Dummy15 != other.Dummy15) return false;
+ if (Dummy16 != other.Dummy16) return false;
+ if (Dummy17 != other.Dummy17) return false;
+ if (Dummy18 != other.Dummy18) return false;
+ if (Dummy19 != other.Dummy19) return false;
+ if (Dummy20 != other.Dummy20) return false;
+ if (Dummy21 != other.Dummy21) return false;
+ if (Dummy22 != other.Dummy22) return false;
+ if (Dummy23 != other.Dummy23) return false;
+ if (Dummy24 != other.Dummy24) return false;
+ if (Dummy25 != other.Dummy25) return false;
+ if (Dummy26 != other.Dummy26) return false;
+ if (Dummy27 != other.Dummy27) return false;
+ if (Dummy28 != other.Dummy28) return false;
+ if (Dummy29 != other.Dummy29) return false;
+ if (Dummy30 != other.Dummy30) return false;
+ if (Dummy31 != other.Dummy31) return false;
+ if (Dummy32 != other.Dummy32) return false;
+ if (C != other.C) return false;
+ return Equals(_unknownFields, other._unknownFields);
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ public override int GetHashCode() {
+ int hash = 1;
+ if (HasA) hash ^= A.GetHashCode();
+ if (HasDummy2) hash ^= Dummy2.GetHashCode();
+ if (HasB) hash ^= B.GetHashCode();
+ if (HasDummy4) hash ^= Dummy4.GetHashCode();
+ if (HasDummy5) hash ^= Dummy5.GetHashCode();
+ if (HasDummy6) hash ^= Dummy6.GetHashCode();
+ if (HasDummy7) hash ^= Dummy7.GetHashCode();
+ if (HasDummy8) hash ^= Dummy8.GetHashCode();
+ if (HasDummy9) hash ^= Dummy9.GetHashCode();
+ if (HasDummy10) hash ^= Dummy10.GetHashCode();
+ if (HasDummy11) hash ^= Dummy11.GetHashCode();
+ if (HasDummy12) hash ^= Dummy12.GetHashCode();
+ if (HasDummy13) hash ^= Dummy13.GetHashCode();
+ if (HasDummy14) hash ^= Dummy14.GetHashCode();
+ if (HasDummy15) hash ^= Dummy15.GetHashCode();
+ if (HasDummy16) hash ^= Dummy16.GetHashCode();
+ if (HasDummy17) hash ^= Dummy17.GetHashCode();
+ if (HasDummy18) hash ^= Dummy18.GetHashCode();
+ if (HasDummy19) hash ^= Dummy19.GetHashCode();
+ if (HasDummy20) hash ^= Dummy20.GetHashCode();
+ if (HasDummy21) hash ^= Dummy21.GetHashCode();
+ if (HasDummy22) hash ^= Dummy22.GetHashCode();
+ if (HasDummy23) hash ^= Dummy23.GetHashCode();
+ if (HasDummy24) hash ^= Dummy24.GetHashCode();
+ if (HasDummy25) hash ^= Dummy25.GetHashCode();
+ if (HasDummy26) hash ^= Dummy26.GetHashCode();
+ if (HasDummy27) hash ^= Dummy27.GetHashCode();
+ if (HasDummy28) hash ^= Dummy28.GetHashCode();
+ if (HasDummy29) hash ^= Dummy29.GetHashCode();
+ if (HasDummy30) hash ^= Dummy30.GetHashCode();
+ if (HasDummy31) hash ^= Dummy31.GetHashCode();
+ if (HasDummy32) hash ^= Dummy32.GetHashCode();
+ if (HasC) hash ^= C.GetHashCode();
+ if (_unknownFields != null) {
+ hash ^= _unknownFields.GetHashCode();
+ }
+ return hash;
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ public override string ToString() {
+ return pb::JsonFormatter.ToDiagnosticString(this);
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
+ if (HasA) {
+ output.WriteRawTag(8);
+ output.WriteInt32(A);
+ }
+ if (HasDummy2) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Dummy2);
+ }
+ if (HasB) {
+ output.WriteRawTag(24);
+ output.WriteInt32(B);
+ }
+ if (HasDummy4) {
+ output.WriteRawTag(32);
+ output.WriteInt32(Dummy4);
+ }
+ if (HasDummy5) {
+ output.WriteRawTag(40);
+ output.WriteInt32(Dummy5);
+ }
+ if (HasDummy6) {
+ output.WriteRawTag(48);
+ output.WriteInt32(Dummy6);
+ }
+ if (HasDummy7) {
+ output.WriteRawTag(56);
+ output.WriteInt32(Dummy7);
+ }
+ if (HasDummy8) {
+ output.WriteRawTag(64);
+ output.WriteInt32(Dummy8);
+ }
+ if (HasDummy9) {
+ output.WriteRawTag(72);
+ output.WriteInt32(Dummy9);
+ }
+ if (HasDummy10) {
+ output.WriteRawTag(80);
+ output.WriteInt32(Dummy10);
+ }
+ if (HasDummy11) {
+ output.WriteRawTag(88);
+ output.WriteInt32(Dummy11);
+ }
+ if (HasDummy12) {
+ output.WriteRawTag(96);
+ output.WriteInt32(Dummy12);
+ }
+ if (HasDummy13) {
+ output.WriteRawTag(104);
+ output.WriteInt32(Dummy13);
+ }
+ if (HasDummy14) {
+ output.WriteRawTag(112);
+ output.WriteInt32(Dummy14);
+ }
+ if (HasDummy15) {
+ output.WriteRawTag(120);
+ output.WriteInt32(Dummy15);
+ }
+ if (HasDummy16) {
+ output.WriteRawTag(128, 1);
+ output.WriteInt32(Dummy16);
+ }
+ if (HasDummy17) {
+ output.WriteRawTag(136, 1);
+ output.WriteInt32(Dummy17);
+ }
+ if (HasDummy18) {
+ output.WriteRawTag(144, 1);
+ output.WriteInt32(Dummy18);
+ }
+ if (HasDummy19) {
+ output.WriteRawTag(152, 1);
+ output.WriteInt32(Dummy19);
+ }
+ if (HasDummy20) {
+ output.WriteRawTag(160, 1);
+ output.WriteInt32(Dummy20);
+ }
+ if (HasDummy21) {
+ output.WriteRawTag(168, 1);
+ output.WriteInt32(Dummy21);
+ }
+ if (HasDummy22) {
+ output.WriteRawTag(176, 1);
+ output.WriteInt32(Dummy22);
+ }
+ if (HasDummy23) {
+ output.WriteRawTag(184, 1);
+ output.WriteInt32(Dummy23);
+ }
+ if (HasDummy24) {
+ output.WriteRawTag(192, 1);
+ output.WriteInt32(Dummy24);
+ }
+ if (HasDummy25) {
+ output.WriteRawTag(200, 1);
+ output.WriteInt32(Dummy25);
+ }
+ if (HasDummy26) {
+ output.WriteRawTag(208, 1);
+ output.WriteInt32(Dummy26);
}
- if (ReferenceEquals(other, this)) {
- return true;
+ if (HasDummy27) {
+ output.WriteRawTag(216, 1);
+ output.WriteInt32(Dummy27);
+ }
+ if (HasDummy28) {
+ output.WriteRawTag(224, 1);
+ output.WriteInt32(Dummy28);
+ }
+ if (HasDummy29) {
+ output.WriteRawTag(232, 1);
+ output.WriteInt32(Dummy29);
+ }
+ if (HasDummy30) {
+ output.WriteRawTag(240, 1);
+ output.WriteInt32(Dummy30);
+ }
+ if (HasDummy31) {
+ output.WriteRawTag(248, 1);
+ output.WriteInt32(Dummy31);
+ }
+ if (HasDummy32) {
+ output.WriteRawTag(128, 2);
+ output.WriteInt32(Dummy32);
+ }
+ if (HasC) {
+ output.WriteRawTag(136, 2);
+ output.WriteInt32(C);
}
- if (A != other.A) return false;
- if (Dummy2 != other.Dummy2) return false;
- if (B != other.B) return false;
- if (Dummy4 != other.Dummy4) return false;
- if (Dummy5 != other.Dummy5) return false;
- if (Dummy6 != other.Dummy6) return false;
- if (Dummy7 != other.Dummy7) return false;
- if (Dummy8 != other.Dummy8) return false;
- if (Dummy9 != other.Dummy9) return false;
- if (Dummy10 != other.Dummy10) return false;
- if (Dummy11 != other.Dummy11) return false;
- if (Dummy12 != other.Dummy12) return false;
- if (Dummy13 != other.Dummy13) return false;
- if (Dummy14 != other.Dummy14) return false;
- if (Dummy15 != other.Dummy15) return false;
- if (Dummy16 != other.Dummy16) return false;
- if (Dummy17 != other.Dummy17) return false;
- if (Dummy18 != other.Dummy18) return false;
- if (Dummy19 != other.Dummy19) return false;
- if (Dummy20 != other.Dummy20) return false;
- if (Dummy21 != other.Dummy21) return false;
- if (Dummy22 != other.Dummy22) return false;
- if (Dummy23 != other.Dummy23) return false;
- if (Dummy24 != other.Dummy24) return false;
- if (Dummy25 != other.Dummy25) return false;
- if (Dummy26 != other.Dummy26) return false;
- if (Dummy27 != other.Dummy27) return false;
- if (Dummy28 != other.Dummy28) return false;
- if (Dummy29 != other.Dummy29) return false;
- if (Dummy30 != other.Dummy30) return false;
- if (Dummy31 != other.Dummy31) return false;
- if (Dummy32 != other.Dummy32) return false;
- if (C != other.C) return false;
- return Equals(_unknownFields, other._unknownFields);
- }
-
- [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public override int GetHashCode() {
- int hash = 1;
- if (HasA) hash ^= A.GetHashCode();
- if (HasDummy2) hash ^= Dummy2.GetHashCode();
- if (HasB) hash ^= B.GetHashCode();
- if (HasDummy4) hash ^= Dummy4.GetHashCode();
- if (HasDummy5) hash ^= Dummy5.GetHashCode();
- if (HasDummy6) hash ^= Dummy6.GetHashCode();
- if (HasDummy7) hash ^= Dummy7.GetHashCode();
- if (HasDummy8) hash ^= Dummy8.GetHashCode();
- if (HasDummy9) hash ^= Dummy9.GetHashCode();
- if (HasDummy10) hash ^= Dummy10.GetHashCode();
- if (HasDummy11) hash ^= Dummy11.GetHashCode();
- if (HasDummy12) hash ^= Dummy12.GetHashCode();
- if (HasDummy13) hash ^= Dummy13.GetHashCode();
- if (HasDummy14) hash ^= Dummy14.GetHashCode();
- if (HasDummy15) hash ^= Dummy15.GetHashCode();
- if (HasDummy16) hash ^= Dummy16.GetHashCode();
- if (HasDummy17) hash ^= Dummy17.GetHashCode();
- if (HasDummy18) hash ^= Dummy18.GetHashCode();
- if (HasDummy19) hash ^= Dummy19.GetHashCode();
- if (HasDummy20) hash ^= Dummy20.GetHashCode();
- if (HasDummy21) hash ^= Dummy21.GetHashCode();
- if (HasDummy22) hash ^= Dummy22.GetHashCode();
- if (HasDummy23) hash ^= Dummy23.GetHashCode();
- if (HasDummy24) hash ^= Dummy24.GetHashCode();
- if (HasDummy25) hash ^= Dummy25.GetHashCode();
- if (HasDummy26) hash ^= Dummy26.GetHashCode();
- if (HasDummy27) hash ^= Dummy27.GetHashCode();
- if (HasDummy28) hash ^= Dummy28.GetHashCode();
- if (HasDummy29) hash ^= Dummy29.GetHashCode();
- if (HasDummy30) hash ^= Dummy30.GetHashCode();
- if (HasDummy31) hash ^= Dummy31.GetHashCode();
- if (HasDummy32) hash ^= Dummy32.GetHashCode();
- if (HasC) hash ^= C.GetHashCode();
if (_unknownFields != null) {
- hash ^= _unknownFields.GetHashCode();
+ _unknownFields.WriteTo(output);
}
- return hash;
- }
-
- [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public override string ToString() {
- return pb::JsonFormatter.ToDiagnosticString(this);
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public void WriteTo(pb::CodedOutputStream output) {
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
if (HasA) {
output.WriteRawTag(8);
output.WriteInt32(A);
@@ -8156,9 +8815,10 @@ public void WriteTo(pb::CodedOutputStream output) {
output.WriteInt32(C);
}
if (_unknownFields != null) {
- _unknownFields.WriteTo(output);
+ _unknownFields.WriteTo(ref output);
}
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8807,6 +9467,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (optionalMessage_ != null) {
output.WriteRawTag(10);
output.WriteMessage(OptionalMessage);
@@ -8819,7 +9482,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (optionalMessage_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(OptionalMessage);
+ }
+ repeatedMessage_.WriteTo(ref output, _repeated_repeatedMessage_codec);
+ if (HasDummy) {
+ output.WriteRawTag(24);
+ output.WriteInt32(Dummy);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -9027,6 +9709,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (optionalMessage_ != null) {
output.WriteRawTag(10);
output.WriteMessage(OptionalMessage);
@@ -9039,7 +9724,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (optionalMessage_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(OptionalMessage);
+ }
+ repeatedMessage_.WriteTo(ref output, _repeated_repeatedMessage_codec);
+ if (requiredMessage_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(RequiredMessage);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -9232,6 +9936,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (foreignNested_ != null) {
output.WriteRawTag(10);
output.WriteMessage(ForeignNested);
@@ -9239,7 +9946,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (foreignNested_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(ForeignNested);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -9385,10 +10106,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -9521,13 +10255,29 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_extensions != null) {
_extensions.WriteTo(output);
}
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -9686,13 +10436,29 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_extensions != null) {
_extensions.WriteTo(output);
}
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -9905,6 +10671,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(8);
output.WriteInt32(A);
@@ -9916,7 +10685,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(8);
+ output.WriteInt32(A);
+ }
+ if (HasBb) {
+ output.WriteRawTag(248, 255, 255, 255, 7);
+ output.WriteInt32(Bb);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -10106,7 +10893,27 @@ public override string ToString() {
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public void WriteTo(pb::CodedOutputStream output) {
+ public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
+ if (a_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(A);
+ }
+ if (HasI) {
+ output.WriteRawTag(16);
+ output.WriteInt32(I);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(output);
+ }
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
if (a_ != null) {
output.WriteRawTag(10);
output.WriteMessage(A);
@@ -10116,9 +10923,10 @@ public void WriteTo(pb::CodedOutputStream output) {
output.WriteInt32(I);
}
if (_unknownFields != null) {
- _unknownFields.WriteTo(output);
+ _unknownFields.WriteTo(ref output);
}
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -10316,6 +11124,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (bb_ != null) {
output.WriteRawTag(10);
output.WriteMessage(Bb);
@@ -10328,7 +11139,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (bb_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(Bb);
+ }
+ if (HasSubGroup) {
+ output.WriteRawTag(19);
+ output.WriteGroup(SubGroup);
+ output.WriteRawTag(20);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -10510,6 +11340,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (b_ != null) {
output.WriteRawTag(10);
output.WriteMessage(B);
@@ -10517,7 +11350,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (b_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(B);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -10691,6 +11538,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (subMessage_ != null) {
output.WriteRawTag(26);
output.WriteMessage(SubMessage);
@@ -10702,7 +11552,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (subMessage_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(SubMessage);
+ }
+ if (notInThisScc_ != null) {
+ output.WriteRawTag(34);
+ output.WriteMessage(NotInThisScc);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -10920,6 +11788,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (a_ != null) {
output.WriteRawTag(10);
output.WriteMessage(A);
@@ -10931,7 +11802,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (a_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(A);
+ }
+ if (HasOptionalInt32) {
+ output.WriteRawTag(16);
+ output.WriteInt32(OptionalInt32);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -11102,6 +11991,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (subMessage_ != null) {
output.WriteRawTag(10);
output.WriteMessage(SubMessage);
@@ -11109,7 +12001,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (subMessage_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(SubMessage);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -11278,6 +12184,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasSubGroup) {
output.WriteRawTag(11);
output.WriteGroup(SubGroup);
@@ -11286,7 +12195,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasSubGroup) {
+ output.WriteRawTag(11);
+ output.WriteGroup(SubGroup);
+ output.WriteRawTag(12);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -11460,6 +12384,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasI) {
output.WriteRawTag(16);
output.WriteInt32(I);
@@ -11467,7 +12394,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasI) {
+ output.WriteRawTag(16);
+ output.WriteInt32(I);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -11701,6 +12642,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(8);
output.WriteInt32(A);
@@ -11718,7 +12662,31 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(8);
+ output.WriteInt32(A);
+ }
+ if (HasFoo) {
+ output.WriteRawTag(19);
+ output.WriteGroup(Foo);
+ output.WriteRawTag(20);
+ }
+ if (HasBar) {
+ output.WriteRawTag(27);
+ output.WriteGroup(Bar);
+ output.WriteRawTag(28);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -11929,6 +12897,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(8);
output.WriteInt32(A);
@@ -11936,7 +12907,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(8);
+ output.WriteInt32(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -12103,6 +13088,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(8);
output.WriteInt32(A);
@@ -12110,7 +13098,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(8);
+ output.WriteInt32(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -12270,6 +13272,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (subMessage_ != null) {
output.WriteRawTag(10);
output.WriteMessage(SubMessage);
@@ -12277,7 +13282,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (subMessage_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(SubMessage);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -12434,6 +13453,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (subMessage_ != null) {
output.WriteRawTag(10);
output.WriteMessage(SubMessage);
@@ -12441,7 +13463,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (subMessage_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(SubMessage);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -12601,6 +13637,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (optionalNestedMessage_ != null) {
output.WriteRawTag(10);
output.WriteMessage(OptionalNestedMessage);
@@ -12608,7 +13647,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (optionalNestedMessage_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(OptionalNestedMessage);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -12779,12 +13832,27 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
nestedmessageRepeatedInt32_.WriteTo(output, _repeated_nestedmessageRepeatedInt32_codec);
nestedmessageRepeatedForeignmessage_.WriteTo(output, _repeated_nestedmessageRepeatedForeignmessage_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ nestedmessageRepeatedInt32_.WriteTo(ref output, _repeated_nestedmessageRepeatedInt32_codec);
+ nestedmessageRepeatedForeignmessage_.WriteTo(ref output, _repeated_nestedmessageRepeatedForeignmessage_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -13161,6 +14229,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasPrimitiveField) {
output.WriteRawTag(8);
output.WriteInt32(PrimitiveField);
@@ -13194,7 +14265,47 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasPrimitiveField) {
+ output.WriteRawTag(8);
+ output.WriteInt32(PrimitiveField);
+ }
+ if (HasStringField) {
+ output.WriteRawTag(18);
+ output.WriteString(StringField);
+ }
+ if (HasEnumField) {
+ output.WriteRawTag(24);
+ output.WriteEnum((int) EnumField);
+ }
+ if (messageField_ != null) {
+ output.WriteRawTag(34);
+ output.WriteMessage(MessageField);
+ }
+ if (HasStringPieceField) {
+ output.WriteRawTag(42);
+ output.WriteString(StringPieceField);
+ }
+ if (HasCordField) {
+ output.WriteRawTag(50);
+ output.WriteString(CordField);
+ }
+ repeatedPrimitiveField_.WriteTo(ref output, _repeated_repeatedPrimitiveField_codec);
+ repeatedStringField_.WriteTo(ref output, _repeated_repeatedStringField_codec);
+ repeatedEnumField_.WriteTo(ref output, _repeated_repeatedEnumField_codec);
+ repeatedMessageField_.WriteTo(ref output, _repeated_repeatedMessageField_codec);
+ repeatedStringPieceField_.WriteTo(ref output, _repeated_repeatedStringPieceField_codec);
+ repeatedCordField_.WriteTo(ref output, _repeated_repeatedCordField_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -13580,6 +14691,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasMyInt) {
output.WriteRawTag(8);
output.WriteInt64(MyInt);
@@ -13602,7 +14716,36 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasMyInt) {
+ output.WriteRawTag(8);
+ output.WriteInt64(MyInt);
+ }
+ if (HasMyString) {
+ output.WriteRawTag(90);
+ output.WriteString(MyString);
+ }
+ if (HasMyFloat) {
+ output.WriteRawTag(173, 6);
+ output.WriteFloat(MyFloat);
+ }
+ if (optionalNestedMessage_ != null) {
+ output.WriteRawTag(194, 12);
+ output.WriteMessage(OptionalNestedMessage);
+ }
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -13880,6 +15023,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasBb) {
output.WriteRawTag(8);
output.WriteInt32(Bb);
@@ -13891,7 +15037,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasBb) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Bb);
+ }
+ if (HasOo) {
+ output.WriteRawTag(16);
+ output.WriteInt64(Oo);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -14070,6 +15234,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasMyString) {
output.WriteRawTag(10);
output.WriteString(MyString);
@@ -14077,7 +15244,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasMyString) {
+ output.WriteRawTag(10);
+ output.WriteString(MyString);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -14246,6 +15427,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasMyString) {
output.WriteRawTag(10);
output.WriteString(MyString);
@@ -14253,7 +15437,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasMyString) {
+ output.WriteRawTag(10);
+ output.WriteString(MyString);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -14415,6 +15613,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasMyString) {
output.WriteRawTag(10);
output.WriteString(MyString);
@@ -14422,7 +15623,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasMyString) {
+ output.WriteRawTag(10);
+ output.WriteString(MyString);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -15326,6 +16541,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasEscapedBytes) {
output.WriteRawTag(10);
output.WriteBytes(EscapedBytes);
@@ -15437,7 +16655,125 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasEscapedBytes) {
+ output.WriteRawTag(10);
+ output.WriteBytes(EscapedBytes);
+ }
+ if (HasLargeUint32) {
+ output.WriteRawTag(16);
+ output.WriteUInt32(LargeUint32);
+ }
+ if (HasLargeUint64) {
+ output.WriteRawTag(24);
+ output.WriteUInt64(LargeUint64);
+ }
+ if (HasSmallInt32) {
+ output.WriteRawTag(32);
+ output.WriteInt32(SmallInt32);
+ }
+ if (HasSmallInt64) {
+ output.WriteRawTag(40);
+ output.WriteInt64(SmallInt64);
+ }
+ if (HasUtf8String) {
+ output.WriteRawTag(50);
+ output.WriteString(Utf8String);
+ }
+ if (HasZeroFloat) {
+ output.WriteRawTag(61);
+ output.WriteFloat(ZeroFloat);
+ }
+ if (HasOneFloat) {
+ output.WriteRawTag(69);
+ output.WriteFloat(OneFloat);
+ }
+ if (HasSmallFloat) {
+ output.WriteRawTag(77);
+ output.WriteFloat(SmallFloat);
+ }
+ if (HasNegativeOneFloat) {
+ output.WriteRawTag(85);
+ output.WriteFloat(NegativeOneFloat);
+ }
+ if (HasNegativeFloat) {
+ output.WriteRawTag(93);
+ output.WriteFloat(NegativeFloat);
+ }
+ if (HasLargeFloat) {
+ output.WriteRawTag(101);
+ output.WriteFloat(LargeFloat);
+ }
+ if (HasSmallNegativeFloat) {
+ output.WriteRawTag(109);
+ output.WriteFloat(SmallNegativeFloat);
+ }
+ if (HasInfDouble) {
+ output.WriteRawTag(113);
+ output.WriteDouble(InfDouble);
+ }
+ if (HasNegInfDouble) {
+ output.WriteRawTag(121);
+ output.WriteDouble(NegInfDouble);
+ }
+ if (HasNanDouble) {
+ output.WriteRawTag(129, 1);
+ output.WriteDouble(NanDouble);
+ }
+ if (HasInfFloat) {
+ output.WriteRawTag(141, 1);
+ output.WriteFloat(InfFloat);
+ }
+ if (HasNegInfFloat) {
+ output.WriteRawTag(149, 1);
+ output.WriteFloat(NegInfFloat);
+ }
+ if (HasNanFloat) {
+ output.WriteRawTag(157, 1);
+ output.WriteFloat(NanFloat);
+ }
+ if (HasCppTrigraph) {
+ output.WriteRawTag(162, 1);
+ output.WriteString(CppTrigraph);
+ }
+ if (HasReallySmallInt32) {
+ output.WriteRawTag(168, 1);
+ output.WriteInt32(ReallySmallInt32);
+ }
+ if (HasReallySmallInt64) {
+ output.WriteRawTag(176, 1);
+ output.WriteInt64(ReallySmallInt64);
+ }
+ if (HasStringWithZero) {
+ output.WriteRawTag(186, 1);
+ output.WriteString(StringWithZero);
+ }
+ if (HasBytesWithZero) {
+ output.WriteRawTag(194, 1);
+ output.WriteBytes(BytesWithZero);
+ }
+ if (HasStringPieceWithZero) {
+ output.WriteRawTag(202, 1);
+ output.WriteString(StringPieceWithZero);
+ }
+ if (HasCordWithZero) {
+ output.WriteRawTag(210, 1);
+ output.WriteString(CordWithZero);
+ }
+ if (HasReplacementString) {
+ output.WriteRawTag(218, 1);
+ output.WriteString(ReplacementString);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -15964,6 +17300,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasSparseEnum) {
output.WriteRawTag(8);
output.WriteEnum((int) SparseEnum);
@@ -15971,7 +17310,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasSparseEnum) {
+ output.WriteRawTag(8);
+ output.WriteEnum((int) SparseEnum);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -16134,6 +17487,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasData) {
output.WriteRawTag(10);
output.WriteString(Data);
@@ -16141,7 +17497,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasData) {
+ output.WriteRawTag(10);
+ output.WriteString(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -16288,11 +17658,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
data_.WriteTo(output, _repeated_data_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ data_.WriteTo(ref output, _repeated_data_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -16447,15 +17831,32 @@ public override string ToString() {
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public void WriteTo(pb::CodedOutputStream output) {
+ public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
+ if (HasData) {
+ output.WriteRawTag(10);
+ output.WriteBytes(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(output);
+ }
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
if (HasData) {
output.WriteRawTag(10);
output.WriteBytes(Data);
}
if (_unknownFields != null) {
- _unknownFields.WriteTo(output);
+ _unknownFields.WriteTo(ref output);
}
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -16602,11 +18003,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
data_.WriteTo(output, _repeated_data_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ data_.WriteTo(ref output, _repeated_data_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -16768,6 +18183,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasData) {
output.WriteRawTag(8);
output.WriteInt32(Data);
@@ -16775,7 +18193,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasData) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -16938,6 +18370,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasData) {
output.WriteRawTag(8);
output.WriteUInt32(Data);
@@ -16945,7 +18380,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasData) {
+ output.WriteRawTag(8);
+ output.WriteUInt32(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -17108,6 +18557,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasData) {
output.WriteRawTag(8);
output.WriteInt64(Data);
@@ -17115,7 +18567,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasData) {
+ output.WriteRawTag(8);
+ output.WriteInt64(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -17278,6 +18744,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasData) {
output.WriteRawTag(8);
output.WriteUInt64(Data);
@@ -17285,7 +18754,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasData) {
+ output.WriteRawTag(8);
+ output.WriteUInt64(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -17448,6 +18931,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasData) {
output.WriteRawTag(8);
output.WriteBool(Data);
@@ -17455,7 +18941,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasData) {
+ output.WriteRawTag(8);
+ output.WriteBool(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -17718,6 +19218,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasFooInt) {
output.WriteRawTag(8);
output.WriteInt32(FooInt);
@@ -17738,7 +19241,34 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasFooInt) {
+ output.WriteRawTag(8);
+ output.WriteInt32(FooInt);
+ }
+ if (HasFooString) {
+ output.WriteRawTag(18);
+ output.WriteString(FooString);
+ }
+ if (fooCase_ == FooOneofCase.FooMessage) {
+ output.WriteRawTag(26);
+ output.WriteMessage(FooMessage);
+ }
+ if (HasFooGroup) {
+ output.WriteRawTag(35);
+ output.WriteGroup(FooGroup);
+ output.WriteRawTag(36);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -18000,6 +19530,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(40);
output.WriteInt32(A);
@@ -18011,7 +19544,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(40);
+ output.WriteInt32(A);
+ }
+ if (HasB) {
+ output.WriteRawTag(50);
+ output.WriteString(B);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -18261,6 +19812,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasFooInt) {
output.WriteRawTag(8);
output.WriteInt32(FooInt);
@@ -18281,7 +19835,34 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasFooInt) {
+ output.WriteRawTag(8);
+ output.WriteInt32(FooInt);
+ }
+ if (HasFooString) {
+ output.WriteRawTag(18);
+ output.WriteString(FooString);
+ }
+ if (fooMessage_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(FooMessage);
+ }
+ if (HasFooGroup) {
+ output.WriteRawTag(35);
+ output.WriteGroup(FooGroup);
+ output.WriteRawTag(36);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -18532,6 +20113,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(40);
output.WriteInt32(A);
@@ -18543,7 +20127,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(40);
+ output.WriteInt32(A);
+ }
+ if (HasB) {
+ output.WriteRawTag(50);
+ output.WriteString(B);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -19209,7 +20811,88 @@ public override string ToString() {
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public void WriteTo(pb::CodedOutputStream output) {
+ public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
+ if (HasFooInt) {
+ output.WriteRawTag(8);
+ output.WriteInt32(FooInt);
+ }
+ if (HasFooString) {
+ output.WriteRawTag(18);
+ output.WriteString(FooString);
+ }
+ if (HasFooCord) {
+ output.WriteRawTag(26);
+ output.WriteString(FooCord);
+ }
+ if (HasFooStringPiece) {
+ output.WriteRawTag(34);
+ output.WriteString(FooStringPiece);
+ }
+ if (HasFooBytes) {
+ output.WriteRawTag(42);
+ output.WriteBytes(FooBytes);
+ }
+ if (HasFooEnum) {
+ output.WriteRawTag(48);
+ output.WriteEnum((int) FooEnum);
+ }
+ if (fooCase_ == FooOneofCase.FooMessage) {
+ output.WriteRawTag(58);
+ output.WriteMessage(FooMessage);
+ }
+ if (HasFooGroup) {
+ output.WriteRawTag(67);
+ output.WriteGroup(FooGroup);
+ output.WriteRawTag(68);
+ }
+ if (fooCase_ == FooOneofCase.FooLazyMessage) {
+ output.WriteRawTag(90);
+ output.WriteMessage(FooLazyMessage);
+ }
+ if (HasBarInt) {
+ output.WriteRawTag(96);
+ output.WriteInt32(BarInt);
+ }
+ if (HasBarString) {
+ output.WriteRawTag(106);
+ output.WriteString(BarString);
+ }
+ if (HasBarCord) {
+ output.WriteRawTag(114);
+ output.WriteString(BarCord);
+ }
+ if (HasBarStringPiece) {
+ output.WriteRawTag(122);
+ output.WriteString(BarStringPiece);
+ }
+ if (HasBarBytes) {
+ output.WriteRawTag(130, 1);
+ output.WriteBytes(BarBytes);
+ }
+ if (HasBarEnum) {
+ output.WriteRawTag(136, 1);
+ output.WriteEnum((int) BarEnum);
+ }
+ if (HasBazInt) {
+ output.WriteRawTag(144, 1);
+ output.WriteInt32(BazInt);
+ }
+ if (HasBazString) {
+ output.WriteRawTag(154, 1);
+ output.WriteString(BazString);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(output);
+ }
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
if (HasFooInt) {
output.WriteRawTag(8);
output.WriteInt32(FooInt);
@@ -19280,9 +20963,10 @@ public void WriteTo(pb::CodedOutputStream output) {
output.WriteString(BazString);
}
if (_unknownFields != null) {
- _unknownFields.WriteTo(output);
+ _unknownFields.WriteTo(ref output);
}
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -19752,6 +21436,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(72);
output.WriteInt32(A);
@@ -19763,7 +21450,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(72);
+ output.WriteInt32(A);
+ }
+ if (HasB) {
+ output.WriteRawTag(82);
+ output.WriteString(B);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -19957,6 +21662,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasQuxInt) {
output.WriteRawTag(8);
output.WriteInt64(QuxInt);
@@ -19965,7 +21673,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasQuxInt) {
+ output.WriteRawTag(8);
+ output.WriteInt64(QuxInt);
+ }
+ corgeInt_.WriteTo(ref output, _repeated_corgeInt_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -20213,6 +21936,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasFooInt) {
output.WriteRawTag(8);
output.WriteInt32(FooInt);
@@ -20228,7 +21954,29 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasFooInt) {
+ output.WriteRawTag(8);
+ output.WriteInt32(FooInt);
+ }
+ if (HasFooString) {
+ output.WriteRawTag(18);
+ output.WriteString(FooString);
+ }
+ if (fooCase_ == FooOneofCase.FooMessage) {
+ output.WriteRawTag(26);
+ output.WriteMessage(FooMessage);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -20437,6 +22185,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasRequiredDouble) {
output.WriteRawTag(9);
output.WriteDouble(RequiredDouble);
@@ -20444,7 +22195,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasRequiredDouble) {
+ output.WriteRawTag(9);
+ output.WriteDouble(RequiredDouble);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -20596,11 +22361,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
foo_.WriteTo(output, _map_foo_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ foo_.WriteTo(ref output, _map_foo_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -20761,6 +22540,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasRequiredInt32) {
output.WriteRawTag(8);
output.WriteInt32(RequiredInt32);
@@ -20768,7 +22550,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasRequiredInt32) {
+ output.WriteRawTag(8);
+ output.WriteInt32(RequiredInt32);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -21089,6 +22885,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
packedInt32_.WriteTo(output, _repeated_packedInt32_codec);
packedInt64_.WriteTo(output, _repeated_packedInt64_codec);
packedUint32_.WriteTo(output, _repeated_packedUint32_codec);
@@ -21106,7 +22905,31 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ packedInt32_.WriteTo(ref output, _repeated_packedInt32_codec);
+ packedInt64_.WriteTo(ref output, _repeated_packedInt64_codec);
+ packedUint32_.WriteTo(ref output, _repeated_packedUint32_codec);
+ packedUint64_.WriteTo(ref output, _repeated_packedUint64_codec);
+ packedSint32_.WriteTo(ref output, _repeated_packedSint32_codec);
+ packedSint64_.WriteTo(ref output, _repeated_packedSint64_codec);
+ packedFixed32_.WriteTo(ref output, _repeated_packedFixed32_codec);
+ packedFixed64_.WriteTo(ref output, _repeated_packedFixed64_codec);
+ packedSfixed32_.WriteTo(ref output, _repeated_packedSfixed32_codec);
+ packedSfixed64_.WriteTo(ref output, _repeated_packedSfixed64_codec);
+ packedFloat_.WriteTo(ref output, _repeated_packedFloat_codec);
+ packedDouble_.WriteTo(ref output, _repeated_packedDouble_codec);
+ packedBool_.WriteTo(ref output, _repeated_packedBool_codec);
+ packedEnum_.WriteTo(ref output, _repeated_packedEnum_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -21580,6 +23403,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
unpackedInt32_.WriteTo(output, _repeated_unpackedInt32_codec);
unpackedInt64_.WriteTo(output, _repeated_unpackedInt64_codec);
unpackedUint32_.WriteTo(output, _repeated_unpackedUint32_codec);
@@ -21597,7 +23423,31 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ unpackedInt32_.WriteTo(ref output, _repeated_unpackedInt32_codec);
+ unpackedInt64_.WriteTo(ref output, _repeated_unpackedInt64_codec);
+ unpackedUint32_.WriteTo(ref output, _repeated_unpackedUint32_codec);
+ unpackedUint64_.WriteTo(ref output, _repeated_unpackedUint64_codec);
+ unpackedSint32_.WriteTo(ref output, _repeated_unpackedSint32_codec);
+ unpackedSint64_.WriteTo(ref output, _repeated_unpackedSint64_codec);
+ unpackedFixed32_.WriteTo(ref output, _repeated_unpackedFixed32_codec);
+ unpackedFixed64_.WriteTo(ref output, _repeated_unpackedFixed64_codec);
+ unpackedSfixed32_.WriteTo(ref output, _repeated_unpackedSfixed32_codec);
+ unpackedSfixed64_.WriteTo(ref output, _repeated_unpackedSfixed64_codec);
+ unpackedFloat_.WriteTo(ref output, _repeated_unpackedFloat_codec);
+ unpackedDouble_.WriteTo(ref output, _repeated_unpackedDouble_codec);
+ unpackedBool_.WriteTo(ref output, _repeated_unpackedBool_codec);
+ unpackedEnum_.WriteTo(ref output, _repeated_unpackedEnum_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -21894,13 +23744,29 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_extensions != null) {
_extensions.WriteTo(output);
}
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -22059,13 +23925,29 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_extensions != null) {
_extensions.WriteTo(output);
}
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -22357,6 +24239,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasScalarExtension) {
output.WriteRawTag(133, 125);
output.WriteFixed32(ScalarExtension);
@@ -22382,7 +24267,39 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasScalarExtension) {
+ output.WriteRawTag(133, 125);
+ output.WriteFixed32(ScalarExtension);
+ }
+ if (HasEnumExtension) {
+ output.WriteRawTag(136, 125);
+ output.WriteEnum((int) EnumExtension);
+ }
+ if (HasDynamicEnumExtension) {
+ output.WriteRawTag(144, 125);
+ output.WriteEnum((int) DynamicEnumExtension);
+ }
+ if (messageExtension_ != null) {
+ output.WriteRawTag(154, 125);
+ output.WriteMessage(MessageExtension);
+ }
+ if (dynamicMessageExtension_ != null) {
+ output.WriteRawTag(162, 125);
+ output.WriteMessage(DynamicMessageExtension);
+ }
+ repeatedExtension_.WriteTo(ref output, _repeated_repeatedExtension_codec);
+ packedExtension_.WriteTo(ref output, _repeated_packedExtension_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -22649,6 +24566,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasDynamicField) {
output.WriteRawTag(160, 131, 1);
output.WriteInt32(DynamicField);
@@ -22656,7 +24576,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasDynamicField) {
+ output.WriteRawTag(160, 131, 1);
+ output.WriteInt32(DynamicField);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -22887,6 +24821,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
repeatedFixed32_.WriteTo(output, _repeated_repeatedFixed32_codec);
repeatedInt32_.WriteTo(output, _repeated_repeatedInt32_codec);
repeatedFixed64_.WriteTo(output, _repeated_repeatedFixed64_codec);
@@ -22896,7 +24833,23 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ repeatedFixed32_.WriteTo(ref output, _repeated_repeatedFixed32_codec);
+ repeatedInt32_.WriteTo(ref output, _repeated_repeatedInt32_codec);
+ repeatedFixed64_.WriteTo(ref output, _repeated_repeatedFixed64_codec);
+ repeatedInt64_.WriteTo(ref output, _repeated_repeatedInt64_codec);
+ repeatedFloat_.WriteTo(ref output, _repeated_repeatedFloat_codec);
+ repeatedUint64_.WriteTo(ref output, _repeated_repeatedUint64_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -23179,6 +25132,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (requiredAllTypes_ != null) {
output.WriteRawTag(10);
output.WriteMessage(RequiredAllTypes);
@@ -23200,7 +25156,35 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (requiredAllTypes_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(RequiredAllTypes);
+ }
+ if (optionalAllTypes_ != null) {
+ output.WriteRawTag(18);
+ output.WriteMessage(OptionalAllTypes);
+ }
+ repeatedAllTypes_.WriteTo(ref output, _repeated_repeatedAllTypes_codec);
+ if (HasOptionalGroup) {
+ output.WriteRawTag(83);
+ output.WriteGroup(OptionalGroup);
+ output.WriteRawTag(84);
+ }
+ repeatedGroup_.WriteTo(ref output, _repeated_repeatedGroup_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -23539,6 +25523,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
field1_.WriteTo(output, _repeated_field1_codec);
field2_.WriteTo(output, _repeated_field2_codec);
field3_.WriteTo(output, _repeated_field3_codec);
@@ -23549,7 +25536,24 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ field1_.WriteTo(ref output, _repeated_field1_codec);
+ field2_.WriteTo(ref output, _repeated_field2_codec);
+ field3_.WriteTo(ref output, _repeated_field3_codec);
+ group1_.WriteTo(ref output, _repeated_group1_codec);
+ group2_.WriteTo(ref output, _repeated_group2_codec);
+ ext1_.WriteTo(ref output, _repeated_ext1_codec);
+ ext2_.WriteTo(ref output, _repeated_ext2_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -23755,6 +25759,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (field1_ != null) {
output.WriteRawTag(90);
output.WriteMessage(Field1);
@@ -23762,7 +25769,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (field1_ != null) {
+ output.WriteRawTag(90);
+ output.WriteMessage(Field1);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -23923,6 +25944,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (field1_ != null) {
output.WriteRawTag(170, 1);
output.WriteMessage(Field1);
@@ -23930,7 +25954,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (field1_ != null) {
+ output.WriteRawTag(170, 1);
+ output.WriteMessage(Field1);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -24096,6 +26134,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (optionalGroupAllTypes_ != null) {
output.WriteRawTag(90);
output.WriteMessage(OptionalGroupAllTypes);
@@ -24103,7 +26144,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (optionalGroupAllTypes_ != null) {
+ output.WriteRawTag(90);
+ output.WriteMessage(OptionalGroupAllTypes);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -24264,6 +26319,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (repeatedGroupAllTypes_ != null) {
output.WriteRawTag(170, 1);
output.WriteMessage(RepeatedGroupAllTypes);
@@ -24271,7 +26329,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (repeatedGroupAllTypes_ != null) {
+ output.WriteRawTag(170, 1);
+ output.WriteMessage(RepeatedGroupAllTypes);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -24463,6 +26535,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasA) {
output.WriteRawTag(10);
output.WriteString(A);
@@ -24470,7 +26545,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasA) {
+ output.WriteRawTag(10);
+ output.WriteString(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -24607,10 +26696,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -24730,10 +26832,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -24853,10 +26968,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -24976,10 +27104,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -25099,10 +27240,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -25222,10 +27376,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -25509,6 +27676,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasFieldName1) {
output.WriteRawTag(8);
output.WriteInt32(FieldName1);
@@ -25536,7 +27706,41 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasFieldName1) {
+ output.WriteRawTag(8);
+ output.WriteInt32(FieldName1);
+ }
+ if (HasFieldName2) {
+ output.WriteRawTag(16);
+ output.WriteInt32(FieldName2);
+ }
+ if (HasFieldName3) {
+ output.WriteRawTag(24);
+ output.WriteInt32(FieldName3);
+ }
+ if (HasFieldName4) {
+ output.WriteRawTag(32);
+ output.WriteInt32(FieldName4);
+ }
+ if (HasFIELDNAME5) {
+ output.WriteRawTag(40);
+ output.WriteInt32(FIELDNAME5);
+ }
+ if (HasFieldName6) {
+ output.WriteRawTag(48);
+ output.WriteInt32(FieldName6);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -26087,6 +28291,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasOptionalInt32) {
output.WriteRawTag(128, 199, 255, 255, 15);
output.WriteInt32(OptionalInt32);
@@ -26141,7 +28348,68 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasOptionalInt32) {
+ output.WriteRawTag(128, 199, 255, 255, 15);
+ output.WriteInt32(OptionalInt32);
+ }
+ if (HasFixed32) {
+ output.WriteRawTag(136, 199, 255, 255, 15);
+ output.WriteInt32(Fixed32);
+ }
+ repeatedInt32_.WriteTo(ref output, _repeated_repeatedInt32_codec);
+ packedInt32_.WriteTo(ref output, _repeated_packedInt32_codec);
+ if (HasOptionalEnum) {
+ output.WriteRawTag(160, 199, 255, 255, 15);
+ output.WriteEnum((int) OptionalEnum);
+ }
+ if (HasOptionalString) {
+ output.WriteRawTag(170, 199, 255, 255, 15);
+ output.WriteString(OptionalString);
+ }
+ if (HasOptionalBytes) {
+ output.WriteRawTag(178, 199, 255, 255, 15);
+ output.WriteBytes(OptionalBytes);
+ }
+ if (optionalMessage_ != null) {
+ output.WriteRawTag(186, 199, 255, 255, 15);
+ output.WriteMessage(OptionalMessage);
+ }
+ if (HasOptionalGroup) {
+ output.WriteRawTag(195, 199, 255, 255, 15);
+ output.WriteGroup(OptionalGroup);
+ output.WriteRawTag(196, 199, 255, 255, 15);
+ }
+ stringStringMap_.WriteTo(ref output, _map_stringStringMap_codec);
+ if (HasOneofUint32) {
+ output.WriteRawTag(216, 199, 255, 255, 15);
+ output.WriteUInt32(OneofUint32);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofTestAllTypes) {
+ output.WriteRawTag(226, 199, 255, 255, 15);
+ output.WriteMessage(OneofTestAllTypes);
+ }
+ if (HasOneofString) {
+ output.WriteRawTag(234, 199, 255, 255, 15);
+ output.WriteString(OneofString);
+ }
+ if (HasOneofBytes) {
+ output.WriteRawTag(242, 199, 255, 255, 15);
+ output.WriteBytes(OneofBytes);
+ }
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -26544,6 +28812,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasGroupA) {
output.WriteRawTag(200, 199, 255, 255, 15);
output.WriteInt32(GroupA);
@@ -26551,7 +28822,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasGroupA) {
+ output.WriteRawTag(200, 199, 255, 255, 15);
+ output.WriteInt32(GroupA);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -26948,6 +29233,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasField1) {
output.WriteRawTag(8);
output.WriteInt32(Field1);
@@ -26990,7 +29278,56 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasField1) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Field1);
+ }
+ if (HasField2) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Field2);
+ }
+ if (HasField3) {
+ output.WriteRawTag(24);
+ output.WriteInt32(Field3);
+ }
+ if (HasField4) {
+ output.WriteRawTag(32);
+ output.WriteInt32(Field4);
+ }
+ if (HasField6) {
+ output.WriteRawTag(48);
+ output.WriteInt32(Field6);
+ }
+ if (HasField7) {
+ output.WriteRawTag(56);
+ output.WriteInt32(Field7);
+ }
+ if (HasField8) {
+ output.WriteRawTag(64);
+ output.WriteInt32(Field8);
+ }
+ if (HasField9) {
+ output.WriteRawTag(72);
+ output.WriteInt32(Field9);
+ }
+ if (HasField10) {
+ output.WriteRawTag(80);
+ output.WriteInt32(Field10);
+ }
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestCustomOptionsProto3.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestCustomOptionsProto3.cs
index 26455da9069e..84a4a7eda20e 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestCustomOptionsProto3.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestCustomOptionsProto3.cs
@@ -379,6 +379,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Field1.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Field1);
@@ -390,7 +393,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Field1.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Field1);
+ }
+ if (anOneofCase_ == AnOneofOneofCase.OneofField) {
+ output.WriteRawTag(16);
+ output.WriteInt32(OneofField);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -558,11 +579,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -681,10 +715,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -804,11 +851,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -927,10 +987,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1050,10 +1123,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1186,11 +1272,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1309,10 +1408,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1432,11 +1544,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1555,11 +1680,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1678,11 +1816,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1801,10 +1952,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1979,6 +2143,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Foo != 0) {
output.WriteRawTag(8);
output.WriteInt32(Foo);
@@ -1995,7 +2162,30 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Foo != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Foo);
+ }
+ if (Foo2 != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Foo2);
+ }
+ if (Foo3 != 0) {
+ output.WriteRawTag(24);
+ output.WriteInt32(Foo3);
+ }
+ foo4_.WriteTo(ref output, _repeated_foo4_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -2224,6 +2414,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (bar_ != null) {
output.WriteRawTag(10);
output.WriteMessage(Bar);
@@ -2240,7 +2433,30 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (bar_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(Bar);
+ }
+ if (Baz != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Baz);
+ }
+ if (fred_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(Fred);
+ }
+ barney_.WriteTo(ref output, _repeated_barney_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -2446,6 +2662,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Waldo != 0) {
output.WriteRawTag(8);
output.WriteInt32(Waldo);
@@ -2453,8 +2672,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Waldo != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Waldo);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -2615,6 +2848,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Qux != 0) {
output.WriteRawTag(8);
output.WriteInt32(Qux);
@@ -2622,8 +2858,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Qux != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Qux);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -2759,11 +3009,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -2930,6 +3193,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (I != 0) {
output.WriteRawTag(8);
output.WriteInt32(I);
@@ -2945,7 +3211,29 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (I != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(I);
+ }
+ if (S.Length != 0) {
+ output.WriteRawTag(18);
+ output.WriteString(S);
+ }
+ if (sub_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(Sub);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -3130,6 +3418,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Fieldname != 0) {
output.WriteRawTag(8);
output.WriteInt32(Fieldname);
@@ -3137,8 +3428,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Fieldname != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Fieldname);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -3274,11 +3579,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -3418,6 +3736,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (NestedField != 0) {
output.WriteRawTag(8);
output.WriteInt32(NestedField);
@@ -3425,7 +3746,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (NestedField != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(NestedField);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImport.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImport.cs
index 6ac9f110693e..14b054ccbbae 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImport.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImport.cs
@@ -157,6 +157,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasD) {
output.WriteRawTag(8);
output.WriteInt32(D);
@@ -164,7 +167,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasD) {
+ output.WriteRawTag(8);
+ output.WriteInt32(D);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportProto3.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportProto3.cs
index 99575b1a3dfe..ecdf40979c2b 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportProto3.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportProto3.cs
@@ -133,6 +133,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (D != 0) {
output.WriteRawTag(8);
output.WriteInt32(D);
@@ -140,7 +143,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (D != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(D);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportPublic.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportPublic.cs
index 9bdcf1d686b5..24c29e970826 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportPublic.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportPublic.cs
@@ -135,6 +135,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasE) {
output.WriteRawTag(8);
output.WriteInt32(E);
@@ -142,7 +145,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasE) {
+ output.WriteRawTag(8);
+ output.WriteInt32(E);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportPublicProto3.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportPublicProto3.cs
index dba9165f4490..2d77a639fa35 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportPublicProto3.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestImportPublicProto3.cs
@@ -121,6 +121,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (E != 0) {
output.WriteRawTag(8);
output.WriteInt32(E);
@@ -128,7 +131,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (E != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(E);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssue6936B.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssue6936B.cs
index 660dbbdda303..e22bf0f8ffb4 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssue6936B.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssue6936B.cs
@@ -106,10 +106,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssue6936C.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssue6936C.cs
index b7498d6f238a..21d36300f87c 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssue6936C.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssue6936C.cs
@@ -122,6 +122,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (foo_ != null) {
output.WriteRawTag(10);
output.WriteMessage(Foo);
@@ -129,7 +132,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (foo_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(Foo);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssues.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssues.cs
index f5c46a95038e..a21a7c042b8e 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssues.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestIssues.cs
@@ -157,10 +157,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -282,11 +295,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -407,11 +433,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -580,6 +619,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.Zero) {
output.WriteRawTag(8);
output.WriteEnum((int) Value);
@@ -589,7 +631,23 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.Zero) {
+ output.WriteRawTag(8);
+ output.WriteEnum((int) Value);
+ }
+ values_.WriteTo(ref output, _repeated_values_codec);
+ packedValues_.WriteTo(ref output, _repeated_packedValues_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -747,11 +805,24 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -957,6 +1028,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (PrimitiveValue != 0) {
output.WriteRawTag(8);
output.WriteInt32(PrimitiveValue);
@@ -975,7 +1049,32 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (PrimitiveValue != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(PrimitiveValue);
+ }
+ primitiveArray_.WriteTo(ref output, _repeated_primitiveArray_codec);
+ if (messageValue_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(MessageValue);
+ }
+ messageArray_.WriteTo(ref output, _repeated_messageArray_codec);
+ if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DeprecatedZero) {
+ output.WriteRawTag(40);
+ output.WriteEnum((int) EnumValue);
+ }
+ enumArray_.WriteTo(ref output, _repeated_enumArray_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1197,6 +1296,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Item != 0) {
output.WriteRawTag(8);
output.WriteInt32(Item);
@@ -1204,7 +1306,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Item != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Item);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1366,6 +1482,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Types_ != 0) {
output.WriteRawTag(8);
output.WriteInt32(Types_);
@@ -1377,7 +1496,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Types_ != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Types_);
+ }
+ if (Descriptor_ != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Descriptor_);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1530,10 +1667,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1810,6 +1960,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (PlainString.Length != 0) {
output.WriteRawTag(10);
output.WriteString(PlainString);
@@ -1837,8 +1990,42 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (PlainString.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(PlainString);
+ }
+ if (o1Case_ == O1OneofCase.O1String) {
+ output.WriteRawTag(18);
+ output.WriteString(O1String);
+ }
+ if (o2Case_ == O2OneofCase.O2String) {
+ output.WriteRawTag(26);
+ output.WriteString(O2String);
+ }
+ if (PlainInt32 != 0) {
+ output.WriteRawTag(32);
+ output.WriteInt32(PlainInt32);
+ }
+ if (o1Case_ == O1OneofCase.O1Int32) {
+ output.WriteRawTag(40);
+ output.WriteInt32(O1Int32);
+ }
+ if (o2Case_ == O2OneofCase.O2Int32) {
+ output.WriteRawTag(48);
+ output.WriteInt32(O2Int32);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -2092,6 +2279,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -2107,8 +2297,30 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (Description.Length != 0) {
+ output.WriteRawTag(18);
+ output.WriteString(Description);
+ }
+ if (Guid.Length != 0) {
+ output.WriteRawTag(26);
+ output.WriteString(Guid);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -2330,6 +2542,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (valueCase_ == ValueOneofCase.Text) {
output.WriteRawTag(10);
output.WriteString(Text);
@@ -2341,7 +2556,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (valueCase_ == ValueOneofCase.Text) {
+ output.WriteRawTag(10);
+ output.WriteString(Text);
+ }
+ if (valueCase_ == ValueOneofCase.Nested) {
+ output.WriteRawTag(18);
+ output.WriteMessage(Nested);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -2535,6 +2768,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (X != 0) {
output.WriteRawTag(8);
output.WriteInt32(X);
@@ -2546,7 +2782,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (X != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(X);
+ }
+ if (Y != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Y);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestProto3.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestProto3.cs
index 468e48bd050f..b81eb573836d 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestProto3.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestProto3.cs
@@ -1019,6 +1019,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (SingleInt32 != 0) {
output.WriteRawTag(8);
output.WriteInt32(SingleInt32);
@@ -1148,8 +1151,144 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (SingleInt32 != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(SingleInt32);
+ }
+ if (SingleInt64 != 0L) {
+ output.WriteRawTag(16);
+ output.WriteInt64(SingleInt64);
+ }
+ if (SingleUint32 != 0) {
+ output.WriteRawTag(24);
+ output.WriteUInt32(SingleUint32);
+ }
+ if (SingleUint64 != 0UL) {
+ output.WriteRawTag(32);
+ output.WriteUInt64(SingleUint64);
+ }
+ if (SingleSint32 != 0) {
+ output.WriteRawTag(40);
+ output.WriteSInt32(SingleSint32);
+ }
+ if (SingleSint64 != 0L) {
+ output.WriteRawTag(48);
+ output.WriteSInt64(SingleSint64);
+ }
+ if (SingleFixed32 != 0) {
+ output.WriteRawTag(61);
+ output.WriteFixed32(SingleFixed32);
+ }
+ if (SingleFixed64 != 0UL) {
+ output.WriteRawTag(65);
+ output.WriteFixed64(SingleFixed64);
+ }
+ if (SingleSfixed32 != 0) {
+ output.WriteRawTag(77);
+ output.WriteSFixed32(SingleSfixed32);
+ }
+ if (SingleSfixed64 != 0L) {
+ output.WriteRawTag(81);
+ output.WriteSFixed64(SingleSfixed64);
+ }
+ if (SingleFloat != 0F) {
+ output.WriteRawTag(93);
+ output.WriteFloat(SingleFloat);
+ }
+ if (SingleDouble != 0D) {
+ output.WriteRawTag(97);
+ output.WriteDouble(SingleDouble);
+ }
+ if (SingleBool != false) {
+ output.WriteRawTag(104);
+ output.WriteBool(SingleBool);
+ }
+ if (SingleString.Length != 0) {
+ output.WriteRawTag(114);
+ output.WriteString(SingleString);
+ }
+ if (SingleBytes.Length != 0) {
+ output.WriteRawTag(122);
+ output.WriteBytes(SingleBytes);
+ }
+ if (singleNestedMessage_ != null) {
+ output.WriteRawTag(146, 1);
+ output.WriteMessage(SingleNestedMessage);
+ }
+ if (singleForeignMessage_ != null) {
+ output.WriteRawTag(154, 1);
+ output.WriteMessage(SingleForeignMessage);
+ }
+ if (singleImportMessage_ != null) {
+ output.WriteRawTag(162, 1);
+ output.WriteMessage(SingleImportMessage);
+ }
+ if (SingleNestedEnum != global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum.Unspecified) {
+ output.WriteRawTag(168, 1);
+ output.WriteEnum((int) SingleNestedEnum);
+ }
+ if (SingleForeignEnum != global::Google.Protobuf.TestProtos.ForeignEnum.ForeignUnspecified) {
+ output.WriteRawTag(176, 1);
+ output.WriteEnum((int) SingleForeignEnum);
+ }
+ if (SingleImportEnum != global::Google.Protobuf.TestProtos.ImportEnum.Unspecified) {
+ output.WriteRawTag(184, 1);
+ output.WriteEnum((int) SingleImportEnum);
+ }
+ if (singlePublicImportMessage_ != null) {
+ output.WriteRawTag(210, 1);
+ output.WriteMessage(SinglePublicImportMessage);
+ }
+ repeatedInt32_.WriteTo(ref output, _repeated_repeatedInt32_codec);
+ repeatedInt64_.WriteTo(ref output, _repeated_repeatedInt64_codec);
+ repeatedUint32_.WriteTo(ref output, _repeated_repeatedUint32_codec);
+ repeatedUint64_.WriteTo(ref output, _repeated_repeatedUint64_codec);
+ repeatedSint32_.WriteTo(ref output, _repeated_repeatedSint32_codec);
+ repeatedSint64_.WriteTo(ref output, _repeated_repeatedSint64_codec);
+ repeatedFixed32_.WriteTo(ref output, _repeated_repeatedFixed32_codec);
+ repeatedFixed64_.WriteTo(ref output, _repeated_repeatedFixed64_codec);
+ repeatedSfixed32_.WriteTo(ref output, _repeated_repeatedSfixed32_codec);
+ repeatedSfixed64_.WriteTo(ref output, _repeated_repeatedSfixed64_codec);
+ repeatedFloat_.WriteTo(ref output, _repeated_repeatedFloat_codec);
+ repeatedDouble_.WriteTo(ref output, _repeated_repeatedDouble_codec);
+ repeatedBool_.WriteTo(ref output, _repeated_repeatedBool_codec);
+ repeatedString_.WriteTo(ref output, _repeated_repeatedString_codec);
+ repeatedBytes_.WriteTo(ref output, _repeated_repeatedBytes_codec);
+ repeatedNestedMessage_.WriteTo(ref output, _repeated_repeatedNestedMessage_codec);
+ repeatedForeignMessage_.WriteTo(ref output, _repeated_repeatedForeignMessage_codec);
+ repeatedImportMessage_.WriteTo(ref output, _repeated_repeatedImportMessage_codec);
+ repeatedNestedEnum_.WriteTo(ref output, _repeated_repeatedNestedEnum_codec);
+ repeatedForeignEnum_.WriteTo(ref output, _repeated_repeatedForeignEnum_codec);
+ repeatedImportEnum_.WriteTo(ref output, _repeated_repeatedImportEnum_codec);
+ repeatedPublicImportMessage_.WriteTo(ref output, _repeated_repeatedPublicImportMessage_codec);
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) {
+ output.WriteRawTag(248, 6);
+ output.WriteUInt32(OneofUint32);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage) {
+ output.WriteRawTag(130, 7);
+ output.WriteMessage(OneofNestedMessage);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofString) {
+ output.WriteRawTag(138, 7);
+ output.WriteString(OneofString);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.OneofBytes) {
+ output.WriteRawTag(146, 7);
+ output.WriteBytes(OneofBytes);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1968,6 +2107,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Bb != 0) {
output.WriteRawTag(8);
output.WriteInt32(Bb);
@@ -1975,7 +2117,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Bb != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Bb);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -2158,6 +2314,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (child_ != null) {
output.WriteRawTag(10);
output.WriteMessage(Child);
@@ -2170,8 +2329,27 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (child_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(Child);
+ }
+ if (payload_ != null) {
+ output.WriteRawTag(18);
+ output.WriteMessage(Payload);
+ }
+ repeatedChild_.WriteTo(ref output, _repeated_repeatedChild_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -2361,6 +2539,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (DeprecatedInt32 != 0) {
output.WriteRawTag(8);
output.WriteInt32(DeprecatedInt32);
@@ -2368,8 +2549,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (DeprecatedInt32 != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(DeprecatedInt32);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -2520,6 +2715,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (C != 0) {
output.WriteRawTag(8);
output.WriteInt32(C);
@@ -2527,8 +2725,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (C != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(C);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -2661,10 +2873,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -2801,6 +3026,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (foreignNested_ != null) {
output.WriteRawTag(10);
output.WriteMessage(ForeignNested);
@@ -2808,7 +3036,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (foreignNested_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(ForeignNested);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -2986,6 +3228,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (A != 0) {
output.WriteRawTag(8);
output.WriteInt32(A);
@@ -2997,8 +3242,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (A != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(A);
+ }
+ if (Bb != 0) {
+ output.WriteRawTag(248, 255, 255, 255, 7);
+ output.WriteInt32(Bb);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -3173,6 +3436,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (a_ != null) {
output.WriteRawTag(10);
output.WriteMessage(A);
@@ -3184,7 +3450,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (a_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(A);
+ }
+ if (I != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(I);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -3358,6 +3642,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (bb_ != null) {
output.WriteRawTag(10);
output.WriteMessage(Bb);
@@ -3365,8 +3652,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (bb_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(Bb);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -3536,6 +3837,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (a_ != null) {
output.WriteRawTag(10);
output.WriteMessage(A);
@@ -3547,8 +3851,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (a_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(A);
+ }
+ if (OptionalInt32 != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(OptionalInt32);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -3718,6 +4040,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value != global::Google.Protobuf.TestProtos.TestEnumWithDupValue.Unspecified) {
output.WriteRawTag(8);
output.WriteEnum((int) Value);
@@ -3725,7 +4050,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value != global::Google.Protobuf.TestProtos.TestEnumWithDupValue.Unspecified) {
+ output.WriteRawTag(8);
+ output.WriteEnum((int) Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -3971,6 +4310,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (PrimitiveField != 0) {
output.WriteRawTag(8);
output.WriteInt32(PrimitiveField);
@@ -3994,8 +4336,38 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (PrimitiveField != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(PrimitiveField);
+ }
+ if (StringField.Length != 0) {
+ output.WriteRawTag(18);
+ output.WriteString(StringField);
+ }
+ if (EnumField != global::Google.Protobuf.TestProtos.ForeignEnum.ForeignUnspecified) {
+ output.WriteRawTag(24);
+ output.WriteEnum((int) EnumField);
+ }
+ if (messageField_ != null) {
+ output.WriteRawTag(34);
+ output.WriteMessage(MessageField);
+ }
+ repeatedPrimitiveField_.WriteTo(ref output, _repeated_repeatedPrimitiveField_codec);
+ repeatedStringField_.WriteTo(ref output, _repeated_repeatedStringField_codec);
+ repeatedEnumField_.WriteTo(ref output, _repeated_repeatedEnumField_codec);
+ repeatedMessageField_.WriteTo(ref output, _repeated_repeatedMessageField_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -4283,6 +4655,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (MyInt != 0L) {
output.WriteRawTag(8);
output.WriteInt64(MyInt);
@@ -4302,7 +4677,33 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (MyInt != 0L) {
+ output.WriteRawTag(8);
+ output.WriteInt64(MyInt);
+ }
+ if (MyString.Length != 0) {
+ output.WriteRawTag(90);
+ output.WriteString(MyString);
+ }
+ if (MyFloat != 0F) {
+ output.WriteRawTag(173, 6);
+ output.WriteFloat(MyFloat);
+ }
+ if (singleNestedMessage_ != null) {
+ output.WriteRawTag(194, 12);
+ output.WriteMessage(SingleNestedMessage);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -4522,6 +4923,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Bb != 0) {
output.WriteRawTag(8);
output.WriteInt32(Bb);
@@ -4533,8 +4937,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Bb != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Bb);
+ }
+ if (Oo != 0L) {
+ output.WriteRawTag(16);
+ output.WriteInt64(Oo);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -4700,6 +5122,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (SparseEnum != global::Google.Protobuf.TestProtos.TestSparseEnum.Unspecified) {
output.WriteRawTag(8);
output.WriteEnum((int) SparseEnum);
@@ -4707,8 +5132,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (SparseEnum != global::Google.Protobuf.TestProtos.TestSparseEnum.Unspecified) {
+ output.WriteRawTag(8);
+ output.WriteEnum((int) SparseEnum);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -4858,6 +5297,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Data.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Data);
@@ -4865,8 +5307,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Data.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -5012,11 +5468,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
data_.WriteTo(output, _repeated_data_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ data_.WriteTo(ref output, _repeated_data_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5159,15 +5629,32 @@ public override string ToString() {
}
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public void WriteTo(pb::CodedOutputStream output) {
+ public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
+ if (Data.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteBytes(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(output);
+ }
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
if (Data.Length != 0) {
output.WriteRawTag(10);
output.WriteBytes(Data);
}
if (_unknownFields != null) {
- _unknownFields.WriteTo(output);
+ _unknownFields.WriteTo(ref output);
}
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5315,6 +5802,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Data.Length != 0) {
output.WriteRawTag(10);
output.WriteBytes(Data);
@@ -5322,7 +5812,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Data.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteBytes(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5473,6 +5977,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Data != 0) {
output.WriteRawTag(8);
output.WriteInt32(Data);
@@ -5480,7 +5987,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Data != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5628,6 +6149,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Data != 0) {
output.WriteRawTag(8);
output.WriteUInt32(Data);
@@ -5635,7 +6159,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Data != 0) {
+ output.WriteRawTag(8);
+ output.WriteUInt32(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5783,6 +6321,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Data != 0L) {
output.WriteRawTag(8);
output.WriteInt64(Data);
@@ -5790,7 +6331,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Data != 0L) {
+ output.WriteRawTag(8);
+ output.WriteInt64(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5938,6 +6493,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Data != 0UL) {
output.WriteRawTag(8);
output.WriteUInt64(Data);
@@ -5945,7 +6503,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Data != 0UL) {
+ output.WriteRawTag(8);
+ output.WriteUInt64(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6093,6 +6665,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Data != false) {
output.WriteRawTag(8);
output.WriteBool(Data);
@@ -6100,7 +6675,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Data != false) {
+ output.WriteRawTag(8);
+ output.WriteBool(Data);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6310,6 +6899,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (fooCase_ == FooOneofCase.FooInt) {
output.WriteRawTag(8);
output.WriteInt32(FooInt);
@@ -6325,7 +6917,29 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (fooCase_ == FooOneofCase.FooInt) {
+ output.WriteRawTag(8);
+ output.WriteInt32(FooInt);
+ }
+ if (fooCase_ == FooOneofCase.FooString) {
+ output.WriteRawTag(18);
+ output.WriteString(FooString);
+ }
+ if (fooCase_ == FooOneofCase.FooMessage) {
+ output.WriteRawTag(26);
+ output.WriteMessage(FooMessage);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6685,6 +7299,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
packedInt32_.WriteTo(output, _repeated_packedInt32_codec);
packedInt64_.WriteTo(output, _repeated_packedInt64_codec);
packedUint32_.WriteTo(output, _repeated_packedUint32_codec);
@@ -6702,7 +7319,31 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ packedInt32_.WriteTo(ref output, _repeated_packedInt32_codec);
+ packedInt64_.WriteTo(ref output, _repeated_packedInt64_codec);
+ packedUint32_.WriteTo(ref output, _repeated_packedUint32_codec);
+ packedUint64_.WriteTo(ref output, _repeated_packedUint64_codec);
+ packedSint32_.WriteTo(ref output, _repeated_packedSint32_codec);
+ packedSint64_.WriteTo(ref output, _repeated_packedSint64_codec);
+ packedFixed32_.WriteTo(ref output, _repeated_packedFixed32_codec);
+ packedFixed64_.WriteTo(ref output, _repeated_packedFixed64_codec);
+ packedSfixed32_.WriteTo(ref output, _repeated_packedSfixed32_codec);
+ packedSfixed64_.WriteTo(ref output, _repeated_packedSfixed64_codec);
+ packedFloat_.WriteTo(ref output, _repeated_packedFloat_codec);
+ packedDouble_.WriteTo(ref output, _repeated_packedDouble_codec);
+ packedBool_.WriteTo(ref output, _repeated_packedBool_codec);
+ packedEnum_.WriteTo(ref output, _repeated_packedEnum_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -7176,6 +7817,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
unpackedInt32_.WriteTo(output, _repeated_unpackedInt32_codec);
unpackedInt64_.WriteTo(output, _repeated_unpackedInt64_codec);
unpackedUint32_.WriteTo(output, _repeated_unpackedUint32_codec);
@@ -7193,7 +7837,31 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ unpackedInt32_.WriteTo(ref output, _repeated_unpackedInt32_codec);
+ unpackedInt64_.WriteTo(ref output, _repeated_unpackedInt64_codec);
+ unpackedUint32_.WriteTo(ref output, _repeated_unpackedUint32_codec);
+ unpackedUint64_.WriteTo(ref output, _repeated_unpackedUint64_codec);
+ unpackedSint32_.WriteTo(ref output, _repeated_unpackedSint32_codec);
+ unpackedSint64_.WriteTo(ref output, _repeated_unpackedSint64_codec);
+ unpackedFixed32_.WriteTo(ref output, _repeated_unpackedFixed32_codec);
+ unpackedFixed64_.WriteTo(ref output, _repeated_unpackedFixed64_codec);
+ unpackedSfixed32_.WriteTo(ref output, _repeated_unpackedSfixed32_codec);
+ unpackedSfixed64_.WriteTo(ref output, _repeated_unpackedSfixed64_codec);
+ unpackedFloat_.WriteTo(ref output, _repeated_unpackedFloat_codec);
+ unpackedDouble_.WriteTo(ref output, _repeated_unpackedDouble_codec);
+ unpackedBool_.WriteTo(ref output, _repeated_unpackedBool_codec);
+ unpackedEnum_.WriteTo(ref output, _repeated_unpackedEnum_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -7573,6 +8241,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
repeatedFixed32_.WriteTo(output, _repeated_repeatedFixed32_codec);
repeatedInt32_.WriteTo(output, _repeated_repeatedInt32_codec);
repeatedFixed64_.WriteTo(output, _repeated_repeatedFixed64_codec);
@@ -7582,7 +8253,23 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ repeatedFixed32_.WriteTo(ref output, _repeated_repeatedFixed32_codec);
+ repeatedInt32_.WriteTo(ref output, _repeated_repeatedInt32_codec);
+ repeatedFixed64_.WriteTo(ref output, _repeated_repeatedFixed64_codec);
+ repeatedInt64_.WriteTo(ref output, _repeated_repeatedInt64_codec);
+ repeatedFloat_.WriteTo(ref output, _repeated_repeatedFloat_codec);
+ repeatedUint64_.WriteTo(ref output, _repeated_repeatedUint64_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -7791,6 +8478,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (A.Length != 0) {
output.WriteRawTag(10);
output.WriteString(A);
@@ -7798,7 +8488,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (A.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(A);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -7935,10 +8639,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8058,10 +8775,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8181,10 +8911,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8304,10 +9047,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8427,10 +9183,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8550,10 +9319,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8673,10 +9455,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8816,6 +9611,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Text.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Text);
@@ -8823,7 +9621,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Text.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Text);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8989,6 +9801,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (NestedText.Length != 0) {
output.WriteRawTag(10);
output.WriteString(NestedText);
@@ -8996,7 +9811,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (NestedText.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(NestedText);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestProto3Optional.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestProto3Optional.cs
index c8cd7f7aa320..451709f4dd44 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestProto3Optional.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestProto3Optional.cs
@@ -622,6 +622,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasOptionalInt32) {
output.WriteRawTag(8);
output.WriteInt32(OptionalInt32);
@@ -709,7 +712,101 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasOptionalInt32) {
+ output.WriteRawTag(8);
+ output.WriteInt32(OptionalInt32);
+ }
+ if (HasOptionalInt64) {
+ output.WriteRawTag(16);
+ output.WriteInt64(OptionalInt64);
+ }
+ if (HasOptionalUint32) {
+ output.WriteRawTag(24);
+ output.WriteUInt32(OptionalUint32);
+ }
+ if (HasOptionalUint64) {
+ output.WriteRawTag(32);
+ output.WriteUInt64(OptionalUint64);
+ }
+ if (HasOptionalSint32) {
+ output.WriteRawTag(40);
+ output.WriteSInt32(OptionalSint32);
+ }
+ if (HasOptionalSint64) {
+ output.WriteRawTag(48);
+ output.WriteSInt64(OptionalSint64);
+ }
+ if (HasOptionalFixed32) {
+ output.WriteRawTag(61);
+ output.WriteFixed32(OptionalFixed32);
+ }
+ if (HasOptionalFixed64) {
+ output.WriteRawTag(65);
+ output.WriteFixed64(OptionalFixed64);
+ }
+ if (HasOptionalSfixed32) {
+ output.WriteRawTag(77);
+ output.WriteSFixed32(OptionalSfixed32);
+ }
+ if (HasOptionalSfixed64) {
+ output.WriteRawTag(81);
+ output.WriteSFixed64(OptionalSfixed64);
+ }
+ if (HasOptionalFloat) {
+ output.WriteRawTag(93);
+ output.WriteFloat(OptionalFloat);
+ }
+ if (HasOptionalDouble) {
+ output.WriteRawTag(97);
+ output.WriteDouble(OptionalDouble);
+ }
+ if (HasOptionalBool) {
+ output.WriteRawTag(104);
+ output.WriteBool(OptionalBool);
+ }
+ if (HasOptionalString) {
+ output.WriteRawTag(114);
+ output.WriteString(OptionalString);
+ }
+ if (HasOptionalBytes) {
+ output.WriteRawTag(122);
+ output.WriteBytes(OptionalBytes);
+ }
+ if (HasOptionalCord) {
+ output.WriteRawTag(130, 1);
+ output.WriteString(OptionalCord);
+ }
+ if (optionalNestedMessage_ != null) {
+ output.WriteRawTag(146, 1);
+ output.WriteMessage(OptionalNestedMessage);
+ }
+ if (lazyNestedMessage_ != null) {
+ output.WriteRawTag(154, 1);
+ output.WriteMessage(LazyNestedMessage);
+ }
+ if (HasOptionalNestedEnum) {
+ output.WriteRawTag(168, 1);
+ output.WriteEnum((int) OptionalNestedEnum);
+ }
+ if (SingularInt32 != 0) {
+ output.WriteRawTag(176, 1);
+ output.WriteInt32(SingularInt32);
+ }
+ if (SingularInt64 != 0L) {
+ output.WriteRawTag(184, 1);
+ output.WriteInt64(SingularInt64);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1186,6 +1283,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasBb) {
output.WriteRawTag(8);
output.WriteInt32(Bb);
@@ -1193,8 +1293,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasBb) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Bb);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestSelfreferentialOptions.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestSelfreferentialOptions.cs
index 4365368acc1e..7ed1580ab2c5 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestSelfreferentialOptions.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestSelfreferentialOptions.cs
@@ -203,6 +203,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasIntOpt) {
output.WriteRawTag(8);
output.WriteInt32(IntOpt);
@@ -217,7 +220,28 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasIntOpt) {
+ output.WriteRawTag(8);
+ output.WriteInt32(IntOpt);
+ }
+ if (HasFoo) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Foo);
+ }
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestWellKnownTypes.cs b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestWellKnownTypes.cs
index 30c906cd4062..996e928cfd52 100644
--- a/csharp/src/Google.Protobuf.Test.TestProtos/UnittestWellKnownTypes.cs
+++ b/csharp/src/Google.Protobuf.Test.TestProtos/UnittestWellKnownTypes.cs
@@ -535,6 +535,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (anyField_ != null) {
output.WriteRawTag(10);
output.WriteMessage(AnyField);
@@ -605,7 +608,84 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (anyField_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(AnyField);
+ }
+ if (apiField_ != null) {
+ output.WriteRawTag(18);
+ output.WriteMessage(ApiField);
+ }
+ if (durationField_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(DurationField);
+ }
+ if (emptyField_ != null) {
+ output.WriteRawTag(34);
+ output.WriteMessage(EmptyField);
+ }
+ if (fieldMaskField_ != null) {
+ output.WriteRawTag(42);
+ output.WriteMessage(FieldMaskField);
+ }
+ if (sourceContextField_ != null) {
+ output.WriteRawTag(50);
+ output.WriteMessage(SourceContextField);
+ }
+ if (structField_ != null) {
+ output.WriteRawTag(58);
+ output.WriteMessage(StructField);
+ }
+ if (timestampField_ != null) {
+ output.WriteRawTag(66);
+ output.WriteMessage(TimestampField);
+ }
+ if (typeField_ != null) {
+ output.WriteRawTag(74);
+ output.WriteMessage(TypeField);
+ }
+ if (doubleField_ != null) {
+ _single_doubleField_codec.WriteTagAndValue(ref output, DoubleField);
+ }
+ if (floatField_ != null) {
+ _single_floatField_codec.WriteTagAndValue(ref output, FloatField);
+ }
+ if (int64Field_ != null) {
+ _single_int64Field_codec.WriteTagAndValue(ref output, Int64Field);
+ }
+ if (uint64Field_ != null) {
+ _single_uint64Field_codec.WriteTagAndValue(ref output, Uint64Field);
+ }
+ if (int32Field_ != null) {
+ _single_int32Field_codec.WriteTagAndValue(ref output, Int32Field);
+ }
+ if (uint32Field_ != null) {
+ _single_uint32Field_codec.WriteTagAndValue(ref output, Uint32Field);
+ }
+ if (boolField_ != null) {
+ _single_boolField_codec.WriteTagAndValue(ref output, BoolField);
+ }
+ if (stringField_ != null) {
+ _single_stringField_codec.WriteTagAndValue(ref output, StringField);
+ }
+ if (bytesField_ != null) {
+ _single_bytesField_codec.WriteTagAndValue(ref output, BytesField);
+ }
+ if (valueField_ != null) {
+ output.WriteRawTag(154, 1);
+ output.WriteMessage(ValueField);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1393,6 +1473,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
anyField_.WriteTo(output, _repeated_anyField_codec);
apiField_.WriteTo(output, _repeated_apiField_codec);
durationField_.WriteTo(output, _repeated_durationField_codec);
@@ -1414,7 +1497,35 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ anyField_.WriteTo(ref output, _repeated_anyField_codec);
+ apiField_.WriteTo(ref output, _repeated_apiField_codec);
+ durationField_.WriteTo(ref output, _repeated_durationField_codec);
+ emptyField_.WriteTo(ref output, _repeated_emptyField_codec);
+ fieldMaskField_.WriteTo(ref output, _repeated_fieldMaskField_codec);
+ sourceContextField_.WriteTo(ref output, _repeated_sourceContextField_codec);
+ structField_.WriteTo(ref output, _repeated_structField_codec);
+ timestampField_.WriteTo(ref output, _repeated_timestampField_codec);
+ typeField_.WriteTo(ref output, _repeated_typeField_codec);
+ doubleField_.WriteTo(ref output, _repeated_doubleField_codec);
+ floatField_.WriteTo(ref output, _repeated_floatField_codec);
+ int64Field_.WriteTo(ref output, _repeated_int64Field_codec);
+ uint64Field_.WriteTo(ref output, _repeated_uint64Field_codec);
+ int32Field_.WriteTo(ref output, _repeated_int32Field_codec);
+ uint32Field_.WriteTo(ref output, _repeated_uint32Field_codec);
+ boolField_.WriteTo(ref output, _repeated_boolField_codec);
+ stringField_.WriteTo(ref output, _repeated_stringField_codec);
+ bytesField_.WriteTo(ref output, _repeated_bytesField_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -2051,6 +2162,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (oneofFieldCase_ == OneofFieldOneofCase.AnyField) {
output.WriteRawTag(10);
output.WriteMessage(AnyField);
@@ -2117,7 +2231,80 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (oneofFieldCase_ == OneofFieldOneofCase.AnyField) {
+ output.WriteRawTag(10);
+ output.WriteMessage(AnyField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.ApiField) {
+ output.WriteRawTag(18);
+ output.WriteMessage(ApiField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.DurationField) {
+ output.WriteRawTag(26);
+ output.WriteMessage(DurationField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.EmptyField) {
+ output.WriteRawTag(34);
+ output.WriteMessage(EmptyField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.FieldMaskField) {
+ output.WriteRawTag(42);
+ output.WriteMessage(FieldMaskField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.SourceContextField) {
+ output.WriteRawTag(50);
+ output.WriteMessage(SourceContextField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.StructField) {
+ output.WriteRawTag(58);
+ output.WriteMessage(StructField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.TimestampField) {
+ output.WriteRawTag(66);
+ output.WriteMessage(TimestampField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.TypeField) {
+ output.WriteRawTag(74);
+ output.WriteMessage(TypeField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.DoubleField) {
+ _oneof_doubleField_codec.WriteTagAndValue(ref output, (double?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.FloatField) {
+ _oneof_floatField_codec.WriteTagAndValue(ref output, (float?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Int64Field) {
+ _oneof_int64Field_codec.WriteTagAndValue(ref output, (long?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Uint64Field) {
+ _oneof_uint64Field_codec.WriteTagAndValue(ref output, (ulong?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Int32Field) {
+ _oneof_int32Field_codec.WriteTagAndValue(ref output, (int?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Uint32Field) {
+ _oneof_uint32Field_codec.WriteTagAndValue(ref output, (uint?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.BoolField) {
+ _oneof_boolField_codec.WriteTagAndValue(ref output, (bool?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.StringField) {
+ _oneof_stringField_codec.WriteTagAndValue(ref output, (string) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.BytesField) {
+ _oneof_bytesField_codec.WriteTagAndValue(ref output, (pb::ByteString) oneofField_);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -2848,6 +3035,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
anyField_.WriteTo(output, _map_anyField_codec);
apiField_.WriteTo(output, _map_apiField_codec);
durationField_.WriteTo(output, _map_durationField_codec);
@@ -2869,8 +3059,36 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ anyField_.WriteTo(ref output, _map_anyField_codec);
+ apiField_.WriteTo(ref output, _map_apiField_codec);
+ durationField_.WriteTo(ref output, _map_durationField_codec);
+ emptyField_.WriteTo(ref output, _map_emptyField_codec);
+ fieldMaskField_.WriteTo(ref output, _map_fieldMaskField_codec);
+ sourceContextField_.WriteTo(ref output, _map_sourceContextField_codec);
+ structField_.WriteTo(ref output, _map_structField_codec);
+ timestampField_.WriteTo(ref output, _map_timestampField_codec);
+ typeField_.WriteTo(ref output, _map_typeField_codec);
+ doubleField_.WriteTo(ref output, _map_doubleField_codec);
+ floatField_.WriteTo(ref output, _map_floatField_codec);
+ int64Field_.WriteTo(ref output, _map_int64Field_codec);
+ uint64Field_.WriteTo(ref output, _map_uint64Field_codec);
+ int32Field_.WriteTo(ref output, _map_int32Field_codec);
+ uint32Field_.WriteTo(ref output, _map_uint32Field_codec);
+ boolField_.WriteTo(ref output, _map_boolField_codec);
+ stringField_.WriteTo(ref output, _map_stringField_codec);
+ bytesField_.WriteTo(ref output, _map_bytesField_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf.Test/Buffers/ArrayBufferWriter.cs b/csharp/src/Google.Protobuf.Test/Buffers/ArrayBufferWriter.cs
new file mode 100644
index 000000000000..8e42d13dab18
--- /dev/null
+++ b/csharp/src/Google.Protobuf.Test/Buffers/ArrayBufferWriter.cs
@@ -0,0 +1,225 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Diagnostics;
+
+namespace Google.Protobuf.Buffers
+{
+ ///
+ /// Represents a heap-based, array-backed output sink into which data can be written.
+ ///
+ /// ArrayBufferWriter is originally from corefx, and has been contributed to Protobuf
+ /// https://github.com/dotnet/runtime/blob/071da4c41aa808c949a773b92dca6f88de9d11f3/src/libraries/Common/src/System/Buffers/ArrayBufferWriter.cs
+ ///
+ internal sealed class ArrayBufferWriter : IBufferWriter
+ {
+ private T[] _buffer;
+ private int _index;
+
+ private const int DefaultInitialBufferSize = 256;
+
+ ///
+ /// Creates an instance of an , in which data can be written to,
+ /// with the default initial capacity.
+ ///
+ public ArrayBufferWriter()
+ {
+ _buffer = new T[0];
+ _index = 0;
+ }
+
+ ///
+ /// Userful for testing writing to buffer writer with a lot of small segments.
+ /// If set, it limits the max number of bytes by which the buffer grows by at once.
+ ///
+ public int? MaxGrowBy { get; set; }
+
+ ///
+ /// Creates an instance of an , in which data can be written to,
+ /// with an initial capacity specified.
+ ///
+ /// The minimum capacity with which to initialize the underlying buffer.
+ ///
+ /// Thrown when is not positive (i.e. less than or equal to 0).
+ ///
+ public ArrayBufferWriter(int initialCapacity)
+ {
+ if (initialCapacity <= 0)
+ throw new ArgumentException(nameof(initialCapacity));
+
+ _buffer = new T[initialCapacity];
+ _index = 0;
+ }
+
+ ///
+ /// Returns the data written to the underlying buffer so far, as a .
+ ///
+ public ReadOnlyMemory WrittenMemory => _buffer.AsMemory(0, _index);
+
+ ///
+ /// Returns the data written to the underlying buffer so far, as a .
+ ///
+ public ReadOnlySpan WrittenSpan => _buffer.AsSpan(0, _index);
+
+ ///
+ /// Returns the amount of data written to the underlying buffer so far.
+ ///
+ public int WrittenCount => _index;
+
+ ///
+ /// Returns the total amount of space within the underlying buffer.
+ ///
+ public int Capacity => _buffer.Length;
+
+ ///
+ /// Returns the amount of space available that can still be written into without forcing the underlying buffer to grow.
+ ///
+ public int FreeCapacity => _buffer.Length - _index;
+
+ ///
+ /// Clears the data written to the underlying buffer.
+ ///
+ ///
+ /// You must clear the before trying to re-use it.
+ ///
+ public void Clear()
+ {
+ Debug.Assert(_buffer.Length >= _index);
+ _buffer.AsSpan(0, _index).Clear();
+ _index = 0;
+ }
+
+ ///
+ /// Notifies that amount of data was written to the output /
+ ///
+ ///
+ /// Thrown when is negative.
+ ///
+ ///
+ /// Thrown when attempting to advance past the end of the underlying buffer.
+ ///
+ ///
+ /// You must request a new buffer after calling Advance to continue writing more data and cannot write to a previously acquired buffer.
+ ///
+ public void Advance(int count)
+ {
+ if (count < 0)
+ throw new ArgumentException(nameof(count));
+
+ if (_index > _buffer.Length - count)
+ throw new InvalidOperationException("Advanced past capacity.");
+
+ _index += count;
+ }
+
+ ///
+ /// Returns a to write to that is at least the requested length (specified by ).
+ /// If no is provided (or it's equal to 0), some non-empty buffer is returned.
+ ///
+ ///
+ /// Thrown when is negative.
+ ///
+ ///
+ /// This will never return an empty .
+ ///
+ ///
+ /// There is no guarantee that successive calls will return the same buffer or the same-sized buffer.
+ ///
+ ///
+ /// You must request a new buffer after calling Advance to continue writing more data and cannot write to a previously acquired buffer.
+ ///
+ public Memory GetMemory(int sizeHint = 0)
+ {
+ CheckAndResizeBuffer(sizeHint);
+ Debug.Assert(_buffer.Length > _index);
+ return _buffer.AsMemory(_index);
+ }
+
+ ///
+ /// Returns a to write to that is at least the requested length (specified by ).
+ /// If no is provided (or it's equal to 0), some non-empty buffer is returned.
+ ///
+ ///
+ /// Thrown when is negative.
+ ///
+ ///
+ /// This will never return an empty .
+ ///
+ ///
+ /// There is no guarantee that successive calls will return the same buffer or the same-sized buffer.
+ ///
+ ///
+ /// You must request a new buffer after calling Advance to continue writing more data and cannot write to a previously acquired buffer.
+ ///
+ public Span GetSpan(int sizeHint = 0)
+ {
+ CheckAndResizeBuffer(sizeHint);
+ Debug.Assert(_buffer.Length > _index);
+ return _buffer.AsSpan(_index);
+ }
+
+ private void CheckAndResizeBuffer(int sizeHint)
+ {
+ if (sizeHint < 0)
+ throw new ArgumentException(nameof(sizeHint));
+
+ if (sizeHint == 0)
+ {
+ sizeHint = 1;
+ }
+
+ if (sizeHint > FreeCapacity)
+ {
+ int growBy = Math.Max(sizeHint, _buffer.Length);
+
+ if (_buffer.Length == 0)
+ {
+ growBy = Math.Max(growBy, DefaultInitialBufferSize);
+ }
+
+ // enable tests that write to small buffer segments
+ if (MaxGrowBy.HasValue && growBy > MaxGrowBy.Value)
+ {
+ growBy = MaxGrowBy.Value;
+ }
+
+ int newSize = checked(_buffer.Length + growBy);
+
+ Array.Resize(ref _buffer, newSize);
+ }
+
+ Debug.Assert(FreeCapacity > 0 && FreeCapacity >= sizeHint);
+ }
+ }
+}
\ No newline at end of file
diff --git a/csharp/src/Google.Protobuf.Test/CodedOutputStreamTest.cs b/csharp/src/Google.Protobuf.Test/CodedOutputStreamTest.cs
index b9ff51521f59..1c77e121d3eb 100644
--- a/csharp/src/Google.Protobuf.Test/CodedOutputStreamTest.cs
+++ b/csharp/src/Google.Protobuf.Test/CodedOutputStreamTest.cs
@@ -33,6 +33,7 @@
using System;
using System.IO;
using Google.Protobuf.TestProtos;
+using Google.Protobuf.Buffers;
using NUnit.Framework;
namespace Google.Protobuf
@@ -48,22 +49,39 @@ private static void AssertWriteVarint(byte[] data, ulong value)
// Only do 32-bit write if the value fits in 32 bits.
if ((value >> 32) == 0)
{
+ // CodedOutputStream
MemoryStream rawOutput = new MemoryStream();
CodedOutputStream output = new CodedOutputStream(rawOutput);
output.WriteRawVarint32((uint) value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
+
+ // IBufferWriter
+ var bufferWriter = new ArrayBufferWriter();
+ WriteContext.Initialize(bufferWriter, out WriteContext ctx);
+ ctx.WriteUInt32((uint) value);
+ ctx.Flush();
+ Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray());
+
// Also try computing size.
Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value));
}
{
+ // CodedOutputStream
MemoryStream rawOutput = new MemoryStream();
CodedOutputStream output = new CodedOutputStream(rawOutput);
output.WriteRawVarint64(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
+ // IBufferWriter
+ var bufferWriter = new ArrayBufferWriter();
+ WriteContext.Initialize(bufferWriter, out WriteContext ctx);
+ ctx.WriteUInt64(value);
+ ctx.Flush();
+ Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray());
+
// Also try computing size.
Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value));
}
@@ -80,6 +98,13 @@ private static void AssertWriteVarint(byte[] data, ulong value)
output.WriteRawVarint32((uint) value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
+
+ var bufferWriter = new ArrayBufferWriter();
+ bufferWriter.MaxGrowBy = bufferSize;
+ WriteContext.Initialize(bufferWriter, out WriteContext ctx);
+ ctx.WriteUInt32((uint) value);
+ ctx.Flush();
+ Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray());
}
{
@@ -88,7 +113,15 @@ private static void AssertWriteVarint(byte[] data, ulong value)
output.WriteRawVarint64(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
+
+ var bufferWriter = new ArrayBufferWriter();
+ bufferWriter.MaxGrowBy = bufferSize;
+ WriteContext.Initialize(bufferWriter, out WriteContext ctx);
+ ctx.WriteUInt64(value);
+ ctx.Flush();
+ Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray());
}
+
}
}
@@ -133,20 +166,35 @@ public void WriteVarint()
///
private static void AssertWriteLittleEndian32(byte[] data, uint value)
{
- MemoryStream rawOutput = new MemoryStream();
- CodedOutputStream output = new CodedOutputStream(rawOutput);
- output.WriteRawLittleEndian32(value);
- output.Flush();
- Assert.AreEqual(data, rawOutput.ToArray());
+ {
+ var rawOutput = new MemoryStream();
+ var output = new CodedOutputStream(rawOutput);
+ output.WriteRawLittleEndian32(value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+
+ var bufferWriter = new ArrayBufferWriter();
+ WriteContext.Initialize(bufferWriter, out WriteContext ctx);
+ ctx.WriteFixed32(value);
+ ctx.Flush();
+ Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray());
+ }
// Try different buffer sizes.
for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2)
{
- rawOutput = new MemoryStream();
- output = new CodedOutputStream(rawOutput, bufferSize);
+ var rawOutput = new MemoryStream();
+ var output = new CodedOutputStream(rawOutput, bufferSize);
output.WriteRawLittleEndian32(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
+
+ var bufferWriter = new ArrayBufferWriter();
+ bufferWriter.MaxGrowBy = bufferSize;
+ WriteContext.Initialize(bufferWriter, out WriteContext ctx);
+ ctx.WriteFixed32(value);
+ ctx.Flush();
+ Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray());
}
}
@@ -156,20 +204,35 @@ private static void AssertWriteLittleEndian32(byte[] data, uint value)
///
private static void AssertWriteLittleEndian64(byte[] data, ulong value)
{
- MemoryStream rawOutput = new MemoryStream();
- CodedOutputStream output = new CodedOutputStream(rawOutput);
- output.WriteRawLittleEndian64(value);
- output.Flush();
- Assert.AreEqual(data, rawOutput.ToArray());
+ {
+ var rawOutput = new MemoryStream();
+ var output = new CodedOutputStream(rawOutput);
+ output.WriteRawLittleEndian64(value);
+ output.Flush();
+ Assert.AreEqual(data, rawOutput.ToArray());
+
+ var bufferWriter = new ArrayBufferWriter();
+ WriteContext.Initialize(bufferWriter, out WriteContext ctx);
+ ctx.WriteFixed64(value);
+ ctx.Flush();
+ Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray());
+ }
// Try different block sizes.
for (int blockSize = 1; blockSize <= 16; blockSize *= 2)
{
- rawOutput = new MemoryStream();
- output = new CodedOutputStream(rawOutput, blockSize);
+ var rawOutput = new MemoryStream();
+ var output = new CodedOutputStream(rawOutput, blockSize);
output.WriteRawLittleEndian64(value);
output.Flush();
Assert.AreEqual(data, rawOutput.ToArray());
+
+ var bufferWriter = new ArrayBufferWriter();
+ bufferWriter.MaxGrowBy = blockSize;
+ WriteContext.Initialize(bufferWriter, out WriteContext ctx);
+ ctx.WriteFixed64(value);
+ ctx.Flush();
+ Assert.AreEqual(data, bufferWriter.WrittenSpan.ToArray());
}
}
@@ -205,41 +268,72 @@ public void WriteWholeMessage_VaryingBlockSizes()
message.WriteTo(output);
output.Flush();
Assert.AreEqual(rawBytes, rawOutput.ToArray());
+
+ var bufferWriter = new ArrayBufferWriter();
+ bufferWriter.MaxGrowBy = blockSize;
+ message.WriteTo(bufferWriter);
+ Assert.AreEqual(rawBytes, bufferWriter.WrittenSpan.ToArray());
}
}
+
+ [Test]
+ public void WriteContext_WritesWithFlushes()
+ {
+ TestAllTypes message = SampleMessages.CreateFullTestAllTypes();
+
+ MemoryStream expectedOutput = new MemoryStream();
+ CodedOutputStream output = new CodedOutputStream(expectedOutput);
+ output.WriteMessage(message);
+ output.Flush();
+ byte[] expectedBytes1 = expectedOutput.ToArray();
+
+ output.WriteMessage(message);
+ output.Flush();
+ byte[] expectedBytes2 = expectedOutput.ToArray();
+
+ var bufferWriter = new ArrayBufferWriter();
+ WriteContext.Initialize(bufferWriter, out WriteContext ctx);
+ ctx.WriteMessage(message);
+ ctx.Flush();
+ Assert.AreEqual(expectedBytes1, bufferWriter.WrittenSpan.ToArray());
+
+ ctx.WriteMessage(message);
+ ctx.Flush();
+ Assert.AreEqual(expectedBytes2, bufferWriter.WrittenSpan.ToArray());
+ }
[Test]
public void EncodeZigZag32()
{
- Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag32(0));
- Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag32(-1));
- Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag32(1));
- Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag32(-2));
- Assert.AreEqual(0x7FFFFFFEu, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF));
- Assert.AreEqual(0x7FFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0xC0000000)));
- Assert.AreEqual(0xFFFFFFFEu, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF));
- Assert.AreEqual(0xFFFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0x80000000)));
+ Assert.AreEqual(0u, WritingPrimitives.EncodeZigZag32(0));
+ Assert.AreEqual(1u, WritingPrimitives.EncodeZigZag32(-1));
+ Assert.AreEqual(2u, WritingPrimitives.EncodeZigZag32(1));
+ Assert.AreEqual(3u, WritingPrimitives.EncodeZigZag32(-2));
+ Assert.AreEqual(0x7FFFFFFEu, WritingPrimitives.EncodeZigZag32(0x3FFFFFFF));
+ Assert.AreEqual(0x7FFFFFFFu, WritingPrimitives.EncodeZigZag32(unchecked((int) 0xC0000000)));
+ Assert.AreEqual(0xFFFFFFFEu, WritingPrimitives.EncodeZigZag32(0x7FFFFFFF));
+ Assert.AreEqual(0xFFFFFFFFu, WritingPrimitives.EncodeZigZag32(unchecked((int) 0x80000000)));
}
[Test]
public void EncodeZigZag64()
{
- Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag64(0));
- Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag64(-1));
- Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag64(1));
- Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag64(-2));
+ Assert.AreEqual(0u, WritingPrimitives.EncodeZigZag64(0));
+ Assert.AreEqual(1u, WritingPrimitives.EncodeZigZag64(-1));
+ Assert.AreEqual(2u, WritingPrimitives.EncodeZigZag64(1));
+ Assert.AreEqual(3u, WritingPrimitives.EncodeZigZag64(-2));
Assert.AreEqual(0x000000007FFFFFFEuL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000003FFFFFFFUL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0x000000003FFFFFFFUL)));
Assert.AreEqual(0x000000007FFFFFFFuL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFFC0000000UL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0xFFFFFFFFC0000000UL)));
Assert.AreEqual(0x00000000FFFFFFFEuL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000007FFFFFFFUL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0x000000007FFFFFFFUL)));
Assert.AreEqual(0x00000000FFFFFFFFuL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFF80000000UL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0xFFFFFFFF80000000UL)));
Assert.AreEqual(0xFFFFFFFFFFFFFFFEL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0x7FFFFFFFFFFFFFFFUL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0x7FFFFFFFFFFFFFFFUL)));
Assert.AreEqual(0xFFFFFFFFFFFFFFFFL,
- CodedOutputStream.EncodeZigZag64(unchecked((long) 0x8000000000000000UL)));
+ WritingPrimitives.EncodeZigZag64(unchecked((long) 0x8000000000000000UL)));
}
[Test]
@@ -247,26 +341,26 @@ public void RoundTripZigZag32()
{
// Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1)
// were chosen semi-randomly via keyboard bashing.
- Assert.AreEqual(0, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0)));
- Assert.AreEqual(1, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1)));
- Assert.AreEqual(-1, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1)));
- Assert.AreEqual(14927, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927)));
- Assert.AreEqual(-3612, ParsingPrimitives.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612)));
+ Assert.AreEqual(0, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(0)));
+ Assert.AreEqual(1, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(1)));
+ Assert.AreEqual(-1, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(-1)));
+ Assert.AreEqual(14927, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(14927)));
+ Assert.AreEqual(-3612, ParsingPrimitives.DecodeZigZag32(WritingPrimitives.EncodeZigZag32(-3612)));
}
[Test]
public void RoundTripZigZag64()
{
- Assert.AreEqual(0, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0)));
- Assert.AreEqual(1, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1)));
- Assert.AreEqual(-1, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1)));
- Assert.AreEqual(14927, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927)));
- Assert.AreEqual(-3612, ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612)));
+ Assert.AreEqual(0, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(0)));
+ Assert.AreEqual(1, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(1)));
+ Assert.AreEqual(-1, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(-1)));
+ Assert.AreEqual(14927, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(14927)));
+ Assert.AreEqual(-3612, ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(-3612)));
Assert.AreEqual(856912304801416L,
- ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L)));
+ ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(856912304801416L)));
Assert.AreEqual(-75123905439571256L,
- ParsingPrimitives.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L)));
+ ParsingPrimitives.DecodeZigZag64(WritingPrimitives.EncodeZigZag64(-75123905439571256L)));
}
[Test]
@@ -395,7 +489,7 @@ public void Dispose_DisposesUnderlyingStream()
Assert.IsTrue(memoryStream.CanWrite);
using (var cos = new CodedOutputStream(memoryStream))
{
- cos.WriteRawByte(0);
+ cos.WriteRawBytes(new byte[] {0});
Assert.AreEqual(0, memoryStream.Position); // Not flushed yet
}
Assert.AreEqual(1, memoryStream.ToArray().Length); // Flushed data from CodedOutputStream to MemoryStream
@@ -409,7 +503,7 @@ public void Dispose_WithLeaveOpen()
Assert.IsTrue(memoryStream.CanWrite);
using (var cos = new CodedOutputStream(memoryStream, true))
{
- cos.WriteRawByte(0);
+ cos.WriteRawBytes(new byte[] {0});
Assert.AreEqual(0, memoryStream.Position); // Not flushed yet
}
Assert.AreEqual(1, memoryStream.Position); // Flushed data from CodedOutputStream to MemoryStream
diff --git a/csharp/src/Google.Protobuf.Test/ExtensionSetTest.cs b/csharp/src/Google.Protobuf.Test/ExtensionSetTest.cs
index 934b780ccc2d..aceb4a68f7b2 100644
--- a/csharp/src/Google.Protobuf.Test/ExtensionSetTest.cs
+++ b/csharp/src/Google.Protobuf.Test/ExtensionSetTest.cs
@@ -34,6 +34,8 @@ public void TestMergeCodedInput()
message.SetExtension(OptionalBoolExtension, true);
var serialized = message.ToByteArray();
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertReadingMessage(
TestAllExtensions.Parser.WithExtensionRegistry(new ExtensionRegistry() { OptionalBoolExtension }),
serialized,
diff --git a/csharp/src/Google.Protobuf.Test/FieldCodecTest.cs b/csharp/src/Google.Protobuf.Test/FieldCodecTest.cs
index 5be0cecd99bd..7f366926fa02 100644
--- a/csharp/src/Google.Protobuf.Test/FieldCodecTest.cs
+++ b/csharp/src/Google.Protobuf.Test/FieldCodecTest.cs
@@ -124,7 +124,17 @@ public void TestRoundTripRaw()
{
var stream = new MemoryStream();
var codedOutput = new CodedOutputStream(stream);
- codec.ValueWriter(codedOutput, sampleValue);
+ WriteContext.Initialize(codedOutput, out WriteContext ctx);
+ try
+ {
+ // only write the value using the codec
+ codec.ValueWriter(ref ctx, sampleValue);
+ }
+ finally
+ {
+ ctx.CopyStateTo(codedOutput);
+ }
+
codedOutput.Flush();
stream.Position = 0;
var codedInput = new CodedInputStream(stream);
@@ -175,7 +185,17 @@ public void TestDefaultValue()
if (codec.DefaultValue != null) // This part isn't appropriate for message types.
{
codedOutput = new CodedOutputStream(stream);
- codec.ValueWriter(codedOutput, codec.DefaultValue);
+ WriteContext.Initialize(codedOutput, out WriteContext ctx);
+ try
+ {
+ // only write the value using the codec
+ codec.ValueWriter(ref ctx, codec.DefaultValue);
+ }
+ finally
+ {
+ ctx.CopyStateTo(codedOutput);
+ }
+
codedOutput.Flush();
Assert.AreNotEqual(0, stream.Position);
Assert.AreEqual(stream.Position, codec.ValueSizeCalculator(codec.DefaultValue));
diff --git a/csharp/src/Google.Protobuf.Test/GeneratedMessageTest.Proto2.cs b/csharp/src/Google.Protobuf.Test/GeneratedMessageTest.Proto2.cs
index 5f90c94cce6d..1abed60563c8 100644
--- a/csharp/src/Google.Protobuf.Test/GeneratedMessageTest.Proto2.cs
+++ b/csharp/src/Google.Protobuf.Test/GeneratedMessageTest.Proto2.cs
@@ -344,6 +344,8 @@ public void RoundTrip_Groups()
}
};
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(Proto2.TestAllTypes.Parser, message);
}
@@ -359,6 +361,8 @@ public void RoundTrip_ExtensionGroups()
new RepeatedGroup_extension { A = 30 }
});
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(
TestAllExtensions.Parser.WithExtensionRegistry(new ExtensionRegistry() { UnittestExtensions.OptionalGroupExtension, UnittestExtensions.RepeatedGroupExtension }),
message);
@@ -370,6 +374,8 @@ public void RoundTrip_NestedExtensionGroup()
var message = new TestGroupExtension();
message.SetExtension(TestNestedExtension.Extensions.OptionalGroupExtension, new TestNestedExtension.Types.OptionalGroup_extension { A = 10 });
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(
TestGroupExtension.Parser.WithExtensionRegistry(new ExtensionRegistry() { TestNestedExtension.Extensions.OptionalGroupExtension }),
message);
diff --git a/csharp/src/Google.Protobuf.Test/GeneratedMessageTest.cs b/csharp/src/Google.Protobuf.Test/GeneratedMessageTest.cs
index 3499e6617d93..06af5e9e9a04 100644
--- a/csharp/src/Google.Protobuf.Test/GeneratedMessageTest.cs
+++ b/csharp/src/Google.Protobuf.Test/GeneratedMessageTest.cs
@@ -132,6 +132,8 @@ public void RoundTrip_Empty()
byte[] bytes = message.ToByteArray();
Assert.AreEqual(0, bytes.Length);
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(TestAllTypes.Parser, message);
}
@@ -164,7 +166,7 @@ public void RoundTrip_SingleValues()
SingleUint64 = ulong.MaxValue
};
- byte[] bytes = message.ToByteArray();
+ MessageParsingHelpers.AssertWritingMessage(message);
MessageParsingHelpers.AssertRoundtrip(TestAllTypes.Parser, message);
}
@@ -198,7 +200,7 @@ public void RoundTrip_RepeatedValues()
RepeatedUint64 = { ulong.MaxValue, uint.MinValue }
};
- byte[] bytes = message.ToByteArray();
+ MessageParsingHelpers.AssertWritingMessage(message);
MessageParsingHelpers.AssertRoundtrip(TestAllTypes.Parser, message);
}
@@ -230,7 +232,7 @@ public void RoundTrip_Maps()
}
};
- byte[] bytes = message.ToByteArray();
+ MessageParsingHelpers.AssertWritingMessage(message);
MessageParsingHelpers.AssertRoundtrip(TestMap.Parser, message);
}
@@ -246,6 +248,8 @@ public void MapWithEmptyEntry()
byte[] bytes = message.ToByteArray();
Assert.AreEqual(2, bytes.Length); // Tag for field entry (1 byte), length of entry (0; 1 byte)
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertReadingMessage(
TestMap.Parser,
bytes,
@@ -660,6 +664,8 @@ public void OneofSerialization_NonDefaultValue()
var bytes = message.ToByteArray();
Assert.AreEqual(3, bytes.Length); // 2 bytes for the tag + 1 for the value - no string!
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(TestAllTypes.Parser, message, parsedMessage =>
{
Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofUint32, parsedMessage.OneofFieldCase);
@@ -675,6 +681,8 @@ public void OneofSerialization_DefaultValue()
var bytes = message.ToByteArray();
Assert.AreEqual(3, bytes.Length); // 2 bytes for the tag + 1 for the value - it's still serialized
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(TestAllTypes.Parser, message, parsedMessage =>
{
Assert.AreEqual(TestAllTypes.OneofFieldOneofCase.OneofUint32, parsedMessage.OneofFieldCase);
diff --git a/csharp/src/Google.Protobuf.Test/LegacyGeneratedCodeTest.cs b/csharp/src/Google.Protobuf.Test/LegacyGeneratedCodeTest.cs
index 9c9846c8f577..da7b4a8c077a 100644
--- a/csharp/src/Google.Protobuf.Test/LegacyGeneratedCodeTest.cs
+++ b/csharp/src/Google.Protobuf.Test/LegacyGeneratedCodeTest.cs
@@ -35,7 +35,9 @@
using pb = global::Google.Protobuf;
using pbr = global::Google.Protobuf.Reflection;
using NUnit.Framework;
-
+using System.IO;
+using System;
+using Google.Protobuf.Buffers;
namespace Google.Protobuf
{
@@ -46,14 +48,14 @@ public void IntermixingOfNewAndLegacyGeneratedCodeWorksWithCodedInputStream()
{
var message = new ParseContextEnabledMessageB
{
- A = new LegacyGeneratedCodeMessageA
- {
- Bb = new ParseContextEnabledMessageB { OptionalInt32 = 12345 }
- },
- OptionalInt32 = 6789
+ A = new LegacyGeneratedCodeMessageA
+ {
+ Bb = new ParseContextEnabledMessageB { OptionalInt32 = 12345 }
+ },
+ OptionalInt32 = 6789
};
var data = message.ToByteArray();
-
+
// when parsing started using CodedInputStream and a message with legacy generated code
// is encountered somewhere in the parse tree, we still need to be able to use its
// MergeFrom(CodedInputStream) method to parse correctly.
@@ -71,11 +73,11 @@ public void LegacyGeneratedCodeThrowsWithReadOnlySequence()
{
var message = new ParseContextEnabledMessageB
{
- A = new LegacyGeneratedCodeMessageA
- {
- Bb = new ParseContextEnabledMessageB { OptionalInt32 = 12345 }
- },
- OptionalInt32 = 6789
+ A = new LegacyGeneratedCodeMessageA
+ {
+ Bb = new ParseContextEnabledMessageB { OptionalInt32 = 12345 }
+ },
+ OptionalInt32 = 6789
};
var data = message.ToByteArray();
@@ -86,13 +88,65 @@ public void LegacyGeneratedCodeThrowsWithReadOnlySequence()
// code up to date.
var exception = Assert.Throws(() =>
{
- ParseContext.Initialize(new ReadOnlySequence(data), out ParseContext parseCtx);
- var parsed = new ParseContextEnabledMessageB();
- ParsingPrimitivesMessages.ReadRawMessage(ref parseCtx, parsed);
+ ParseContext.Initialize(new ReadOnlySequence(data), out ParseContext parseCtx);
+ var parsed = new ParseContextEnabledMessageB();
+ ParsingPrimitivesMessages.ReadRawMessage(ref parseCtx, parsed);
});
Assert.AreEqual($"Message {typeof(LegacyGeneratedCodeMessageA).Name} doesn't provide the generated method that enables ParseContext-based parsing. You might need to regenerate the generated protobuf code.", exception.Message);
}
+ [Test]
+ public void IntermixingOfNewAndLegacyGeneratedCodeWorksWithCodedOutputStream()
+ {
+ // when serialization started using CodedOutputStream and a message with legacy generated code
+ // is encountered somewhere in the parse tree, we still need to be able to use its
+ // WriteTo(CodedOutputStream) method to serialize correctly.
+ var ms = new MemoryStream();
+ var codedOutput = new CodedOutputStream(ms);
+ var message = new ParseContextEnabledMessageB
+ {
+ A = new LegacyGeneratedCodeMessageA
+ {
+ Bb = new ParseContextEnabledMessageB { OptionalInt32 = 12345 }
+ },
+ OptionalInt32 = 6789
+ };
+ message.WriteTo(codedOutput);
+ codedOutput.Flush();
+
+ var codedInput = new CodedInputStream(ms.ToArray());
+ var parsed = new ParseContextEnabledMessageB();
+ codedInput.ReadRawMessage(parsed);
+ Assert.IsTrue(codedInput.IsAtEnd);
+
+ Assert.AreEqual(12345, parsed.A.Bb.OptionalInt32);
+ Assert.AreEqual(6789, parsed.OptionalInt32);
+ }
+
+ [Test]
+ public void LegacyGeneratedCodeThrowsWithIBufferWriter()
+ {
+ // if serialization started using IBufferWriter and we don't have a CodedOutputStream
+ // instance at hand, we cannot fall back to the legacy WriteTo(CodedOutputStream)
+ // method and serializatin will fail. As a consequence, one can only use serialization
+ // to IBufferWriter if all the messages in the parsing tree have their generated
+ // code up to date.
+ var message = new ParseContextEnabledMessageB
+ {
+ A = new LegacyGeneratedCodeMessageA
+ {
+ Bb = new ParseContextEnabledMessageB { OptionalInt32 = 12345 }
+ },
+ OptionalInt32 = 6789
+ };
+ var exception = Assert.Throws(() =>
+ {
+ WriteContext.Initialize(new ArrayBufferWriter(), out WriteContext writeCtx);
+ ((IBufferMessage)message).InternalWriteTo(ref writeCtx);
+ });
+ Assert.AreEqual($"Message {typeof(LegacyGeneratedCodeMessageA).Name} doesn't provide the generated method that enables WriteContext-based serialization. You might need to regenerate the generated protobuf code.", exception.Message);
+ }
+
// hand-modified version of a generated message that only provides the legacy
// MergeFrom(CodedInputStream) method and doesn't implement IBufferMessage.
private sealed partial class LegacyGeneratedCodeMessageA : pb::IMessage {
@@ -178,18 +232,27 @@ public int OptionalInt32 {
}
public void WriteTo(pb::CodedOutputStream output) {
- if (a_ != null) {
+ output.WriteRawMessage(this);
+ }
+
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output)
+ {
+ if (a_ != null)
+ {
output.WriteRawTag(10);
output.WriteMessage(A);
}
- if (OptionalInt32 != 0) {
+ if (OptionalInt32 != 0)
+ {
output.WriteRawTag(16);
output.WriteInt32(OptionalInt32);
}
- if (_unknownFields != null) {
- _unknownFields.WriteTo(output);
+ if (_unknownFields != null)
+ {
+ _unknownFields.WriteTo(ref output);
}
}
+
public int CalculateSize() {
int size = 0;
if (a_ != null) {
diff --git a/csharp/src/Google.Protobuf.Test/MessageParsingHelpers.cs b/csharp/src/Google.Protobuf.Test/MessageParsingHelpers.cs
index ec5f13abc354..36a2f0222946 100644
--- a/csharp/src/Google.Protobuf.Test/MessageParsingHelpers.cs
+++ b/csharp/src/Google.Protobuf.Test/MessageParsingHelpers.cs
@@ -33,6 +33,7 @@
using NUnit.Framework;
using System;
using System.Buffers;
+using Google.Protobuf.Buffers;
namespace Google.Protobuf
{
@@ -81,6 +82,11 @@ public static void AssertRoundtrip(MessageParser parser, T message, Action
{
var bytes = message.ToByteArray();
+ // also serialize using IBufferWriter and check it leads to the same data
+ var bufferWriter = new ArrayBufferWriter();
+ message.WriteTo(bufferWriter);
+ Assert.AreEqual(bytes, bufferWriter.WrittenSpan.ToArray(), "Both serialization approaches need to result in the same data.");
+
// Load content as single segment
var parsedBuffer = parser.ParseFrom(new ReadOnlySequence(bytes));
Assert.AreEqual(message, parsedBuffer);
@@ -96,5 +102,41 @@ public static void AssertRoundtrip(MessageParser parser, T message, Action
Assert.AreEqual(message, parsedStream);
additionalAssert?.Invoke(parsedStream);
}
+
+ public static void AssertWritingMessage(IMessage message)
+ {
+ // serialize using CodedOutputStream
+ var bytes = message.ToByteArray();
+
+ int messageSize = message.CalculateSize();
+ Assert.AreEqual(message.CalculateSize(), bytes.Length);
+
+ // serialize using IBufferWriter and check it leads to the same output
+ var bufferWriter = new ArrayBufferWriter();
+ message.WriteTo(bufferWriter);
+ Assert.AreEqual(bytes, bufferWriter.WrittenSpan.ToArray());
+
+ // serialize into a single span and check it leads to the same output
+ var singleSpan = new Span(new byte[messageSize]);
+ message.WriteTo(singleSpan);
+ Assert.AreEqual(bytes, singleSpan.ToArray());
+
+ // test for different IBufferWriter.GetSpan() segment sizes
+ for (int blockSize = 1; blockSize < 256; blockSize *= 2)
+ {
+ var segmentedBufferWriter = new ArrayBufferWriter();
+ segmentedBufferWriter.MaxGrowBy = blockSize;
+ message.WriteTo(segmentedBufferWriter);
+ Assert.AreEqual(bytes, segmentedBufferWriter.WrittenSpan.ToArray());
+ }
+
+ // if the full message is small enough, try serializing directly into stack-allocated buffer
+ if (bytes.Length <= 256)
+ {
+ Span stackAllocBuffer = stackalloc byte[bytes.Length];
+ message.WriteTo(stackAllocBuffer);
+ Assert.AreEqual(bytes, stackAllocBuffer.ToArray());
+ }
+ }
}
}
\ No newline at end of file
diff --git a/csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs b/csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs
index 47ff2a18ed45..94c4746a80dc 100644
--- a/csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs
+++ b/csharp/src/Google.Protobuf.Test/WellKnownTypes/WrappersTest.cs
@@ -71,6 +71,8 @@ public void NonDefaultSingleValues()
Uint64Field = 4
};
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(TestWellKnownTypes.Parser, message, parsed =>
{
Assert.AreEqual("x", parsed.StringField);
@@ -101,6 +103,8 @@ public void NonNullDefaultIsPreservedThroughSerialization()
Uint64Field = 0
};
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(TestWellKnownTypes.Parser, message, parsed =>
{
Assert.AreEqual("", parsed.StringField);
@@ -144,6 +148,8 @@ public void RepeatedWrappersSerializeDeserialize()
// Just to test a single value for sanity...
Assert.AreEqual("Second", message.StringField[1]);
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(RepeatedWellKnownTypes.Parser, message);
}
@@ -169,6 +175,8 @@ public void RepeatedWrappersBinaryFormat()
var message = new RepeatedWellKnownTypes { Int32Field = { 5, 0 } };
var actualBytes = message.ToByteArray();
Assert.AreEqual(expectedBytes, actualBytes);
+
+ MessageParsingHelpers.AssertWritingMessage(message);
}
[Test]
@@ -196,6 +204,8 @@ public void MapWrappersSerializeDeserialize()
// Just to test a single value for sanity...
Assert.AreEqual("Second", message.StringField[12]);
+ MessageParsingHelpers.AssertWritingMessage(message);
+
MessageParsingHelpers.AssertRoundtrip(MapWellKnownTypes.Parser, message);
}
diff --git a/csharp/src/Google.Protobuf/CodedOutputStream.ComputeSize.cs b/csharp/src/Google.Protobuf/CodedOutputStream.ComputeSize.cs
index aa7932470ba3..cb923549d42e 100644
--- a/csharp/src/Google.Protobuf/CodedOutputStream.ComputeSize.cs
+++ b/csharp/src/Google.Protobuf/CodedOutputStream.ComputeSize.cs
@@ -132,7 +132,7 @@ public static int ComputeBoolSize(bool value)
///
public static int ComputeStringSize(String value)
{
- int byteArraySize = Utf8Encoding.GetByteCount(value);
+ int byteArraySize = WritingPrimitives.Utf8Encoding.GetByteCount(value);
return ComputeLengthSize(byteArraySize) + byteArraySize;
}
@@ -208,7 +208,7 @@ public static int ComputeSFixed64Size(long value)
///
public static int ComputeSInt32Size(int value)
{
- return ComputeRawVarint32Size(EncodeZigZag32(value));
+ return ComputeRawVarint32Size(WritingPrimitives.EncodeZigZag32(value));
}
///
@@ -217,7 +217,7 @@ public static int ComputeSInt32Size(int value)
///
public static int ComputeSInt64Size(long value)
{
- return ComputeRawVarint64Size(EncodeZigZag64(value));
+ return ComputeRawVarint64Size(WritingPrimitives.EncodeZigZag64(value));
}
///
diff --git a/csharp/src/Google.Protobuf/CodedOutputStream.cs b/csharp/src/Google.Protobuf/CodedOutputStream.cs
index 1d76d276029d..20d88ea7dc9b 100644
--- a/csharp/src/Google.Protobuf/CodedOutputStream.cs
+++ b/csharp/src/Google.Protobuf/CodedOutputStream.cs
@@ -33,6 +33,7 @@
using Google.Protobuf.Collections;
using System;
using System.IO;
+using System.Security;
using System.Text;
namespace Google.Protobuf
@@ -55,11 +56,9 @@ namespace Google.Protobuf
/// and MapField<TKey, TValue> to serialize such fields.
///
///
+ [SecuritySafeCritical]
public sealed partial class CodedOutputStream : IDisposable
{
- // "Local" copy of Encoding.UTF8, for efficiency. (Yes, it makes a difference.)
- internal static readonly Encoding Utf8Encoding = Encoding.UTF8;
-
///
/// The buffer size used by CreateInstance(Stream).
///
@@ -67,8 +66,8 @@ public sealed partial class CodedOutputStream : IDisposable
private readonly bool leaveOpen;
private readonly byte[] buffer;
- private readonly int limit;
- private int position;
+ private WriterInternalState state;
+
private readonly Stream output;
#region Construction
@@ -90,8 +89,9 @@ private CodedOutputStream(byte[] buffer, int offset, int length)
{
this.output = null;
this.buffer = ProtoPreconditions.CheckNotNull(buffer, nameof(buffer));
- this.position = offset;
- this.limit = offset + length;
+ this.state.position = offset;
+ this.state.limit = offset + length;
+ WriteBufferHelper.Initialize(this, out this.state.writeBufferHelper);
leaveOpen = true; // Simple way of avoiding trying to dispose of a null reference
}
@@ -99,8 +99,9 @@ private CodedOutputStream(Stream output, byte[] buffer, bool leaveOpen)
{
this.output = ProtoPreconditions.CheckNotNull(output, nameof(output));
this.buffer = buffer;
- this.position = 0;
- this.limit = buffer.Length;
+ this.state.position = 0;
+ this.state.limit = buffer.Length;
+ WriteBufferHelper.Initialize(this, out this.state.writeBufferHelper);
this.leaveOpen = leaveOpen;
}
@@ -155,9 +156,9 @@ public long Position
{
if (output != null)
{
- return output.Position + position;
+ return output.Position + state.position;
}
- return position;
+ return state.position;
}
}
@@ -169,7 +170,8 @@ public long Position
/// The value to write
public void WriteDouble(double value)
{
- WriteRawLittleEndian64((ulong)BitConverter.DoubleToInt64Bits(value));
+ var span = new Span(buffer);
+ WritingPrimitives.WriteDouble(ref span, ref state, value);
}
///
@@ -178,23 +180,8 @@ public void WriteDouble(double value)
/// The value to write
public void WriteFloat(float value)
{
- byte[] rawBytes = BitConverter.GetBytes(value);
- if (!BitConverter.IsLittleEndian)
- {
- ByteArray.Reverse(rawBytes);
- }
-
- if (limit - position >= 4)
- {
- buffer[position++] = rawBytes[0];
- buffer[position++] = rawBytes[1];
- buffer[position++] = rawBytes[2];
- buffer[position++] = rawBytes[3];
- }
- else
- {
- WriteRawBytes(rawBytes, 0, 4);
- }
+ var span = new Span(buffer);
+ WritingPrimitives.WriteFloat(ref span, ref state, value);
}
///
@@ -203,7 +190,8 @@ public void WriteFloat(float value)
/// The value to write
public void WriteUInt64(ulong value)
{
- WriteRawVarint64(value);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteUInt64(ref span, ref state, value);
}
///
@@ -212,7 +200,8 @@ public void WriteUInt64(ulong value)
/// The value to write
public void WriteInt64(long value)
{
- WriteRawVarint64((ulong) value);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteInt64(ref span, ref state, value);
}
///
@@ -221,15 +210,8 @@ public void WriteInt64(long value)
/// The value to write
public void WriteInt32(int value)
{
- if (value >= 0)
- {
- WriteRawVarint32((uint) value);
- }
- else
- {
- // Must sign-extend.
- WriteRawVarint64((ulong) value);
- }
+ var span = new Span(buffer);
+ WritingPrimitives.WriteInt32(ref span, ref state, value);
}
///
@@ -238,7 +220,8 @@ public void WriteInt32(int value)
/// The value to write
public void WriteFixed64(ulong value)
{
- WriteRawLittleEndian64(value);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteFixed64(ref span, ref state, value);
}
///
@@ -247,7 +230,8 @@ public void WriteFixed64(ulong value)
/// The value to write
public void WriteFixed32(uint value)
{
- WriteRawLittleEndian32(value);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteFixed32(ref span, ref state, value);
}
///
@@ -256,7 +240,8 @@ public void WriteFixed32(uint value)
/// The value to write
public void WriteBool(bool value)
{
- WriteRawByte(value ? (byte) 1 : (byte) 0);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteBool(ref span, ref state, value);
}
///
@@ -266,41 +251,52 @@ public void WriteBool(bool value)
/// The value to write
public void WriteString(string value)
{
- // Optimise the case where we have enough space to write
- // the string directly to the buffer, which should be common.
- int length = Utf8Encoding.GetByteCount(value);
- WriteLength(length);
- if (limit - position >= length)
+ var span = new Span(buffer);
+ WritingPrimitives.WriteString(ref span, ref state, value);
+ }
+
+ ///
+ /// Writes a message, without a tag, to the stream.
+ /// The data is length-prefixed.
+ ///
+ /// The value to write
+ public void WriteMessage(IMessage value)
+ {
+ // TODO(jtattermusch): if the message doesn't implement IBufferMessage (and thus does not provide the InternalWriteTo method),
+ // what we're doing here works fine, but could be more efficient.
+ // For now, this inefficiency is fine, considering this is only a backward-compatibility scenario (and regenerating the code fixes it).
+ var span = new Span(buffer);
+ WriteContext.Initialize(ref span, ref state, out WriteContext ctx);
+ try
{
- if (length == value.Length) // Must be all ASCII...
- {
- for (int i = 0; i < length; i++)
- {
- buffer[position + i] = (byte)value[i];
- }
- }
- else
- {
- Utf8Encoding.GetBytes(value, 0, value.Length, buffer, position);
- }
- position += length;
+ WritingPrimitivesMessages.WriteMessage(ref ctx, value);
}
- else
+ finally
{
- byte[] bytes = Utf8Encoding.GetBytes(value);
- WriteRawBytes(bytes);
+ ctx.CopyStateTo(this);
}
}
///
/// Writes a message, without a tag, to the stream.
- /// The data is length-prefixed.
+ /// Only the message data is written, without a length-delimiter.
///
/// The value to write
- public void WriteMessage(IMessage value)
- {
- WriteLength(value.CalculateSize());
- value.WriteTo(this);
+ public void WriteRawMessage(IMessage value)
+ {
+ // TODO(jtattermusch): if the message doesn't implement IBufferMessage (and thus does not provide the InternalWriteTo method),
+ // what we're doing here works fine, but could be more efficient.
+ // For now, this inefficiency is fine, considering this is only a backward-compatibility scenario (and regenerating the code fixes it).
+ var span = new Span(buffer);
+ WriteContext.Initialize(ref span, ref state, out WriteContext ctx);
+ try
+ {
+ WritingPrimitivesMessages.WriteRawMessage(ref ctx, value);
+ }
+ finally
+ {
+ ctx.CopyStateTo(this);
+ }
}
///
@@ -309,7 +305,16 @@ public void WriteMessage(IMessage value)
/// The value to write
public void WriteGroup(IMessage value)
{
- value.WriteTo(this);
+ var span = new Span(buffer);
+ WriteContext.Initialize(ref span, ref state, out WriteContext ctx);
+ try
+ {
+ WritingPrimitivesMessages.WriteGroup(ref ctx, value);
+ }
+ finally
+ {
+ ctx.CopyStateTo(this);
+ }
}
///
@@ -319,8 +324,8 @@ public void WriteGroup(IMessage value)
/// The value to write
public void WriteBytes(ByteString value)
{
- WriteLength(value.Length);
- value.WriteRawBytesTo(this);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteBytes(ref span, ref state, value);
}
///
@@ -329,7 +334,8 @@ public void WriteBytes(ByteString value)
/// The value to write
public void WriteUInt32(uint value)
{
- WriteRawVarint32(value);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteUInt32(ref span, ref state, value);
}
///
@@ -338,7 +344,8 @@ public void WriteUInt32(uint value)
/// The value to write
public void WriteEnum(int value)
{
- WriteInt32(value);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteEnum(ref span, ref state, value);
}
///
@@ -347,7 +354,8 @@ public void WriteEnum(int value)
/// The value to write.
public void WriteSFixed32(int value)
{
- WriteRawLittleEndian32((uint) value);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteSFixed32(ref span, ref state, value);
}
///
@@ -356,7 +364,8 @@ public void WriteSFixed32(int value)
/// The value to write
public void WriteSFixed64(long value)
{
- WriteRawLittleEndian64((ulong) value);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteSFixed64(ref span, ref state, value);
}
///
@@ -365,7 +374,8 @@ public void WriteSFixed64(long value)
/// The value to write
public void WriteSInt32(int value)
{
- WriteRawVarint32(EncodeZigZag32(value));
+ var span = new Span(buffer);
+ WritingPrimitives.WriteSInt32(ref span, ref state, value);
}
///
@@ -374,7 +384,8 @@ public void WriteSInt32(int value)
/// The value to write
public void WriteSInt64(long value)
{
- WriteRawVarint64(EncodeZigZag64(value));
+ var span = new Span(buffer);
+ WritingPrimitives.WriteSInt64(ref span, ref state, value);
}
///
@@ -386,7 +397,8 @@ public void WriteSInt64(long value)
/// Length value, in bytes.
public void WriteLength(int length)
{
- WriteRawVarint32((uint) length);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteLength(ref span, ref state, length);
}
#endregion
@@ -399,7 +411,8 @@ public void WriteLength(int length)
/// The wire format type of the tag to write
public void WriteTag(int fieldNumber, WireFormat.WireType type)
{
- WriteRawVarint32(WireFormat.MakeTag(fieldNumber, type));
+ var span = new Span(buffer);
+ WritingPrimitives.WriteTag(ref span, ref state, fieldNumber, type);
}
///
@@ -408,7 +421,8 @@ public void WriteTag(int fieldNumber, WireFormat.WireType type)
/// The encoded tag
public void WriteTag(uint tag)
{
- WriteRawVarint32(tag);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteTag(ref span, ref state, tag);
}
///
@@ -417,7 +431,8 @@ public void WriteTag(uint tag)
/// The encoded tag
public void WriteRawTag(byte b1)
{
- WriteRawByte(b1);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawTag(ref span, ref state, b1);
}
///
@@ -427,8 +442,8 @@ public void WriteRawTag(byte b1)
/// The second byte of the encoded tag
public void WriteRawTag(byte b1, byte b2)
{
- WriteRawByte(b1);
- WriteRawByte(b2);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2);
}
///
@@ -439,9 +454,8 @@ public void WriteRawTag(byte b1, byte b2)
/// The third byte of the encoded tag
public void WriteRawTag(byte b1, byte b2, byte b3)
{
- WriteRawByte(b1);
- WriteRawByte(b2);
- WriteRawByte(b3);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2, b3);
}
///
@@ -453,10 +467,8 @@ public void WriteRawTag(byte b1, byte b2, byte b3)
/// The fourth byte of the encoded tag
public void WriteRawTag(byte b1, byte b2, byte b3, byte b4)
{
- WriteRawByte(b1);
- WriteRawByte(b2);
- WriteRawByte(b3);
- WriteRawByte(b4);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2, b3, b4);
}
///
@@ -469,15 +481,13 @@ public void WriteRawTag(byte b1, byte b2, byte b3, byte b4)
/// The fifth byte of the encoded tag
public void WriteRawTag(byte b1, byte b2, byte b3, byte b4, byte b5)
{
- WriteRawByte(b1);
- WriteRawByte(b2);
- WriteRawByte(b3);
- WriteRawByte(b4);
- WriteRawByte(b5);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawTag(ref span, ref state, b1, b2, b3, b4, b5);
}
#endregion
#region Underlying writing primitives
+
///
/// Writes a 32 bit value as a varint. The fast route is taken when
/// there's enough buffer space left to whizz through without checking
@@ -485,112 +495,26 @@ public void WriteRawTag(byte b1, byte b2, byte b3, byte b4, byte b5)
///
internal void WriteRawVarint32(uint value)
{
- // Optimize for the common case of a single byte value
- if (value < 128 && position < limit)
- {
- buffer[position++] = (byte)value;
- return;
- }
-
- while (value > 127 && position < limit)
- {
- buffer[position++] = (byte) ((value & 0x7F) | 0x80);
- value >>= 7;
- }
- while (value > 127)
- {
- WriteRawByte((byte) ((value & 0x7F) | 0x80));
- value >>= 7;
- }
- if (position < limit)
- {
- buffer[position++] = (byte) value;
- }
- else
- {
- WriteRawByte((byte) value);
- }
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawVarint32(ref span, ref state, value);
}
internal void WriteRawVarint64(ulong value)
{
- while (value > 127 && position < limit)
- {
- buffer[position++] = (byte) ((value & 0x7F) | 0x80);
- value >>= 7;
- }
- while (value > 127)
- {
- WriteRawByte((byte) ((value & 0x7F) | 0x80));
- value >>= 7;
- }
- if (position < limit)
- {
- buffer[position++] = (byte) value;
- }
- else
- {
- WriteRawByte((byte) value);
- }
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawVarint64(ref span, ref state, value);
}
internal void WriteRawLittleEndian32(uint value)
{
- if (position + 4 > limit)
- {
- WriteRawByte((byte) value);
- WriteRawByte((byte) (value >> 8));
- WriteRawByte((byte) (value >> 16));
- WriteRawByte((byte) (value >> 24));
- }
- else
- {
- buffer[position++] = ((byte) value);
- buffer[position++] = ((byte) (value >> 8));
- buffer[position++] = ((byte) (value >> 16));
- buffer[position++] = ((byte) (value >> 24));
- }
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawLittleEndian32(ref span, ref state, value);
}
internal void WriteRawLittleEndian64(ulong value)
{
- if (position + 8 > limit)
- {
- WriteRawByte((byte) value);
- WriteRawByte((byte) (value >> 8));
- WriteRawByte((byte) (value >> 16));
- WriteRawByte((byte) (value >> 24));
- WriteRawByte((byte) (value >> 32));
- WriteRawByte((byte) (value >> 40));
- WriteRawByte((byte) (value >> 48));
- WriteRawByte((byte) (value >> 56));
- }
- else
- {
- buffer[position++] = ((byte) value);
- buffer[position++] = ((byte) (value >> 8));
- buffer[position++] = ((byte) (value >> 16));
- buffer[position++] = ((byte) (value >> 24));
- buffer[position++] = ((byte) (value >> 32));
- buffer[position++] = ((byte) (value >> 40));
- buffer[position++] = ((byte) (value >> 48));
- buffer[position++] = ((byte) (value >> 56));
- }
- }
-
- internal void WriteRawByte(byte value)
- {
- if (position == limit)
- {
- RefreshBuffer();
- }
-
- buffer[position++] = value;
- }
-
- internal void WriteRawByte(uint value)
- {
- WriteRawByte((byte) value);
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawLittleEndian64(ref span, ref state, value);
}
///
@@ -606,85 +530,12 @@ internal void WriteRawBytes(byte[] value)
///
internal void WriteRawBytes(byte[] value, int offset, int length)
{
- if (limit - position >= length)
- {
- ByteArray.Copy(value, offset, buffer, position, length);
- // We have room in the current buffer.
- position += length;
- }
- else
- {
- // Write extends past current buffer. Fill the rest of this buffer and
- // flush.
- int bytesWritten = limit - position;
- ByteArray.Copy(value, offset, buffer, position, bytesWritten);
- offset += bytesWritten;
- length -= bytesWritten;
- position = limit;
- RefreshBuffer();
-
- // Now deal with the rest.
- // Since we have an output stream, this is our buffer
- // and buffer offset == 0
- if (length <= limit)
- {
- // Fits in new buffer.
- ByteArray.Copy(value, offset, buffer, 0, length);
- position = length;
- }
- else
- {
- // Write is very big. Let's do it all at once.
- output.Write(value, offset, length);
- }
- }
+ var span = new Span(buffer);
+ WritingPrimitives.WriteRawBytes(ref span, ref state, value, offset, length);
}
#endregion
- ///
- /// Encode a 32-bit value with ZigZag encoding.
- ///
- ///
- /// ZigZag encodes signed integers into values that can be efficiently
- /// encoded with varint. (Otherwise, negative values must be
- /// sign-extended to 64 bits to be varint encoded, thus always taking
- /// 10 bytes on the wire.)
- ///
- internal static uint EncodeZigZag32(int n)
- {
- // Note: the right-shift must be arithmetic
- return (uint) ((n << 1) ^ (n >> 31));
- }
-
- ///
- /// Encode a 64-bit value with ZigZag encoding.
- ///
- ///
- /// ZigZag encodes signed integers into values that can be efficiently
- /// encoded with varint. (Otherwise, negative values must be
- /// sign-extended to 64 bits to be varint encoded, thus always taking
- /// 10 bytes on the wire.)
- ///
- internal static ulong EncodeZigZag64(long n)
- {
- return (ulong) ((n << 1) ^ (n >> 63));
- }
-
- private void RefreshBuffer()
- {
- if (output == null)
- {
- // We're writing to a single buffer.
- throw new OutOfSpaceException();
- }
-
- // Since we have an output stream, this is our buffer
- // and buffer offset == 0
- output.Write(buffer, 0, position);
- position = 0;
- }
-
///
/// Indicates that a CodedOutputStream wrapping a flat byte array
/// ran out of space.
@@ -726,45 +577,31 @@ public void Dispose()
///
public void Flush()
{
- if (output != null)
- {
- RefreshBuffer();
- }
+ var span = new Span(buffer);
+ WriteBufferHelper.Flush(ref span, ref state);
}
///
/// Verifies that SpaceLeft returns zero. It's common to create a byte array
/// that is exactly big enough to hold a message, then write to it with
/// a CodedOutputStream. Calling CheckNoSpaceLeft after writing verifies that
- /// the message was actually as big as expected, which can help bugs.
+ /// the message was actually as big as expected, which can help finding bugs.
///
public void CheckNoSpaceLeft()
{
- if (SpaceLeft != 0)
- {
- throw new InvalidOperationException("Did not write as much data as expected.");
- }
+ WriteBufferHelper.CheckNoSpaceLeft(ref state);
}
///
/// If writing to a flat array, returns the space left in the array. Otherwise,
/// throws an InvalidOperationException.
///
- public int SpaceLeft
- {
- get
- {
- if (output == null)
- {
- return limit - position;
- }
- else
- {
- throw new InvalidOperationException(
- "SpaceLeft can only be called on CodedOutputStreams that are " +
- "writing to a flat array.");
- }
- }
- }
+ public int SpaceLeft => WriteBufferHelper.GetSpaceLeft(ref state);
+
+ internal byte[] InternalBuffer => buffer;
+
+ internal Stream InternalOutputStream => output;
+
+ internal ref WriterInternalState InternalState => ref state;
}
}
diff --git a/csharp/src/Google.Protobuf/Collections/MapField.cs b/csharp/src/Google.Protobuf/Collections/MapField.cs
index 48cd7ab445a6..d60ebc5a8a58 100644
--- a/csharp/src/Google.Protobuf/Collections/MapField.cs
+++ b/csharp/src/Google.Protobuf/Collections/MapField.cs
@@ -464,14 +464,34 @@ public void AddEntriesFrom(ref ParseContext ctx, Codec codec)
/// The output stream to write to.
/// The codec to use for each entry.
public void WriteTo(CodedOutputStream output, Codec codec)
+ {
+ WriteContext.Initialize(output, out WriteContext ctx);
+ try
+ {
+ WriteTo(ref ctx, codec);
+ }
+ finally
+ {
+ ctx.CopyStateTo(output);
+ }
+ }
+
+ ///
+ /// Writes the contents of this map to the given write context, using the specified codec
+ /// to encode each entry.
+ ///
+ /// The write context to write to.
+ /// The codec to use for each entry.
+ [SecuritySafeCritical]
+ public void WriteTo(ref WriteContext ctx, Codec codec)
{
var message = new Codec.MessageAdapter(codec);
foreach (var entry in list)
{
message.Key = entry.Key;
message.Value = entry.Value;
- output.WriteTag(codec.MapTag);
- output.WriteMessage(message);
+ ctx.WriteTag(codec.MapTag);
+ ctx.WriteMessage(message);
}
}
@@ -711,8 +731,15 @@ public void InternalMergeFrom(ref ParseContext ctx)
public void WriteTo(CodedOutputStream output)
{
- codec.keyCodec.WriteTagAndValue(output, Key);
- codec.valueCodec.WriteTagAndValue(output, Value);
+ // Message adapter is an internal class and we know that all the writing will happen via InternalWriteTo.
+ throw new NotImplementedException();
+ }
+
+ [SecuritySafeCritical]
+ public void InternalWriteTo(ref WriteContext ctx)
+ {
+ codec.keyCodec.WriteTagAndValue(ref ctx, Key);
+ codec.valueCodec.WriteTagAndValue(ref ctx, Value);
}
public int CalculateSize()
diff --git a/csharp/src/Google.Protobuf/Collections/RepeatedField.cs b/csharp/src/Google.Protobuf/Collections/RepeatedField.cs
index b1bd9b13d116..69adcdfafc6c 100644
--- a/csharp/src/Google.Protobuf/Collections/RepeatedField.cs
+++ b/csharp/src/Google.Protobuf/Collections/RepeatedField.cs
@@ -189,7 +189,7 @@ private bool IsDataAvailable(ref ParseContext ctx, int size)
/// Calculates the size of this collection based on the given codec.
///
/// The codec to use when encoding each field.
- /// The number of bytes that would be written to a by ,
+ /// The number of bytes that would be written to an output by one of the WriteTo methods,
/// using the same codec.
public int CalculateSize(FieldCodec codec)
{
@@ -247,6 +247,26 @@ private int CalculatePackedDataSize(FieldCodec codec)
/// The output stream to write to.
/// The codec to use when encoding each value.
public void WriteTo(CodedOutputStream output, FieldCodec codec)
+ {
+ WriteContext.Initialize(output, out WriteContext ctx);
+ try
+ {
+ WriteTo(ref ctx, codec);
+ }
+ finally
+ {
+ ctx.CopyStateTo(output);
+ }
+ }
+
+ ///
+ /// Writes the contents of this collection to the given write context,
+ /// encoding each value using the specified codec.
+ ///
+ /// The write context to write to.
+ /// The codec to use when encoding each value.
+ [SecuritySafeCritical]
+ public void WriteTo(ref WriteContext ctx, FieldCodec codec)
{
if (count == 0)
{
@@ -257,12 +277,12 @@ public void WriteTo(CodedOutputStream output, FieldCodec codec)
if (codec.PackedRepeatedField)
{
// Packed primitive type
- uint size = (uint)CalculatePackedDataSize(codec);
- output.WriteTag(tag);
- output.WriteRawVarint32(size);
+ int size = CalculatePackedDataSize(codec);
+ ctx.WriteTag(tag);
+ ctx.WriteLength(size);
for (int i = 0; i < count; i++)
{
- writer(output, array[i]);
+ writer(ref ctx, array[i]);
}
}
else
@@ -271,11 +291,11 @@ public void WriteTo(CodedOutputStream output, FieldCodec codec)
// Can't use codec.WriteTagAndValue, as that omits default values.
for (int i = 0; i < count; i++)
{
- output.WriteTag(tag);
- writer(output, array[i]);
+ ctx.WriteTag(tag);
+ writer(ref ctx, array[i]);
if (codec.EndTag != 0)
{
- output.WriteTag(codec.EndTag);
+ ctx.WriteTag(codec.EndTag);
}
}
}
diff --git a/csharp/src/Google.Protobuf/ExtensionSet.cs b/csharp/src/Google.Protobuf/ExtensionSet.cs
index dd0b9a5519a7..895b9ae6ea4a 100644
--- a/csharp/src/Google.Protobuf/ExtensionSet.cs
+++ b/csharp/src/Google.Protobuf/ExtensionSet.cs
@@ -34,6 +34,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
+using System.Security;
namespace Google.Protobuf
{
@@ -343,10 +344,28 @@ public int CalculateSize()
/// Writes the extension values in this set to the output stream
///
public void WriteTo(CodedOutputStream stream)
+ {
+
+ WriteContext.Initialize(stream, out WriteContext ctx);
+ try
+ {
+ WriteTo(ref ctx);
+ }
+ finally
+ {
+ ctx.CopyStateTo(stream);
+ }
+ }
+
+ ///
+ /// Writes the extension values in this set to the write context
+ ///
+ [SecuritySafeCritical]
+ public void WriteTo(ref WriteContext ctx)
{
foreach (var value in ValuesByNumber.Values)
{
- value.WriteTo(stream);
+ value.WriteTo(ref ctx);
}
}
diff --git a/csharp/src/Google.Protobuf/ExtensionValue.cs b/csharp/src/Google.Protobuf/ExtensionValue.cs
index df934ed7a1e6..ada5d79c8083 100644
--- a/csharp/src/Google.Protobuf/ExtensionValue.cs
+++ b/csharp/src/Google.Protobuf/ExtensionValue.cs
@@ -41,7 +41,7 @@ internal interface IExtensionValue : IEquatable, IDeepCloneable
void MergeFrom(ref ParseContext ctx);
void MergeFrom(IExtensionValue value);
- void WriteTo(CodedOutputStream output);
+ void WriteTo(ref WriteContext ctx);
int CalculateSize();
bool IsInitialized();
}
@@ -106,13 +106,13 @@ public void MergeFrom(IExtensionValue value)
}
}
- public void WriteTo(CodedOutputStream output)
+ public void WriteTo(ref WriteContext ctx)
{
- output.WriteTag(codec.Tag);
- codec.ValueWriter(output, field);
+ ctx.WriteTag(codec.Tag);
+ codec.ValueWriter(ref ctx, field);
if (codec.EndTag != 0)
{
- output.WriteTag(codec.EndTag);
+ ctx.WriteTag(codec.EndTag);
}
}
@@ -181,11 +181,6 @@ public override int GetHashCode()
}
}
- public void MergeFrom(CodedInputStream input)
- {
- field.AddEntriesFrom(input, codec);
- }
-
public void MergeFrom(ref ParseContext ctx)
{
field.AddEntriesFrom(ref ctx, codec);
@@ -199,9 +194,9 @@ public void MergeFrom(IExtensionValue value)
}
}
- public void WriteTo(CodedOutputStream output)
+ public void WriteTo(ref WriteContext ctx)
{
- field.WriteTo(output, codec);
+ field.WriteTo(ref ctx, codec);
}
public RepeatedField GetValue() => field;
diff --git a/csharp/src/Google.Protobuf/FieldCodec.cs b/csharp/src/Google.Protobuf/FieldCodec.cs
index ee87736d1f31..158739d50ae2 100644
--- a/csharp/src/Google.Protobuf/FieldCodec.cs
+++ b/csharp/src/Google.Protobuf/FieldCodec.cs
@@ -219,7 +219,7 @@ public static FieldCodec ForEnum(uint tag, Func toInt32, FuncA codec for the given tag.
public static FieldCodec ForString(uint tag, string defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadString(), (output, value) => output.WriteString(value), CodedOutputStream.ComputeStringSize, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadString(), (ref WriteContext ctx, string value) => ctx.WriteString(value), CodedOutputStream.ComputeStringSize, tag, defaultValue);
}
///
@@ -230,7 +230,7 @@ public static FieldCodec ForString(uint tag, string defaultValue)
/// A codec for the given tag.
public static FieldCodec ForBytes(uint tag, ByteString defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadBytes(), (output, value) => output.WriteBytes(value), CodedOutputStream.ComputeBytesSize, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadBytes(), (ref WriteContext ctx, ByteString value) => ctx.WriteBytes(value), CodedOutputStream.ComputeBytesSize, tag, defaultValue);
}
///
@@ -241,7 +241,7 @@ public static FieldCodec ForBytes(uint tag, ByteString defaultValue)
/// A codec for the given tag.
public static FieldCodec ForBool(uint tag, bool defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadBool(), (output, value) => output.WriteBool(value), CodedOutputStream.BoolSize, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadBool(), (ref WriteContext ctx, bool value) => ctx.WriteBool(value), CodedOutputStream.BoolSize, tag, defaultValue);
}
///
@@ -252,7 +252,7 @@ public static FieldCodec ForBool(uint tag, bool defaultValue)
/// A codec for the given tag.
public static FieldCodec ForInt32(uint tag, int defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadInt32(), (output, value) => output.WriteInt32(value), CodedOutputStream.ComputeInt32Size, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadInt32(), (ref WriteContext output, int value) => output.WriteInt32(value), CodedOutputStream.ComputeInt32Size, tag, defaultValue);
}
///
@@ -263,7 +263,7 @@ public static FieldCodec ForInt32(uint tag, int defaultValue)
/// A codec for the given tag.
public static FieldCodec ForSInt32(uint tag, int defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadSInt32(), (output, value) => output.WriteSInt32(value), CodedOutputStream.ComputeSInt32Size, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadSInt32(), (ref WriteContext output, int value) => output.WriteSInt32(value), CodedOutputStream.ComputeSInt32Size, tag, defaultValue);
}
///
@@ -274,7 +274,7 @@ public static FieldCodec ForSInt32(uint tag, int defaultValue)
/// A codec for the given tag.
public static FieldCodec ForFixed32(uint tag, uint defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadFixed32(), (output, value) => output.WriteFixed32(value), 4, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadFixed32(), (ref WriteContext output, uint value) => output.WriteFixed32(value), 4, tag, defaultValue);
}
///
@@ -285,7 +285,7 @@ public static FieldCodec ForFixed32(uint tag, uint defaultValue)
/// A codec for the given tag.
public static FieldCodec ForSFixed32(uint tag, int defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadSFixed32(), (output, value) => output.WriteSFixed32(value), 4, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadSFixed32(), (ref WriteContext output, int value) => output.WriteSFixed32(value), 4, tag, defaultValue);
}
///
@@ -296,7 +296,7 @@ public static FieldCodec ForSFixed32(uint tag, int defaultValue)
/// A codec for the given tag.
public static FieldCodec ForUInt32(uint tag, uint defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadUInt32(), (output, value) => output.WriteUInt32(value), CodedOutputStream.ComputeUInt32Size, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadUInt32(), (ref WriteContext output, uint value) => output.WriteUInt32(value), CodedOutputStream.ComputeUInt32Size, tag, defaultValue);
}
///
@@ -307,7 +307,7 @@ public static FieldCodec ForUInt32(uint tag, uint defaultValue)
/// A codec for the given tag.
public static FieldCodec ForInt64(uint tag, long defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadInt64(), (output, value) => output.WriteInt64(value), CodedOutputStream.ComputeInt64Size, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadInt64(), (ref WriteContext output, long value) => output.WriteInt64(value), CodedOutputStream.ComputeInt64Size, tag, defaultValue);
}
///
@@ -318,7 +318,7 @@ public static FieldCodec ForInt64(uint tag, long defaultValue)
/// A codec for the given tag.
public static FieldCodec ForSInt64(uint tag, long defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadSInt64(), (output, value) => output.WriteSInt64(value), CodedOutputStream.ComputeSInt64Size, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadSInt64(), (ref WriteContext output, long value) => output.WriteSInt64(value), CodedOutputStream.ComputeSInt64Size, tag, defaultValue);
}
///
@@ -329,7 +329,7 @@ public static FieldCodec ForSInt64(uint tag, long defaultValue)
/// A codec for the given tag.
public static FieldCodec ForFixed64(uint tag, ulong defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadFixed64(), (output, value) => output.WriteFixed64(value), 8, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadFixed64(), (ref WriteContext output, ulong value) => output.WriteFixed64(value), 8, tag, defaultValue);
}
///
@@ -340,7 +340,7 @@ public static FieldCodec ForFixed64(uint tag, ulong defaultValue)
/// A codec for the given tag.
public static FieldCodec ForSFixed64(uint tag, long defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadSFixed64(), (output, value) => output.WriteSFixed64(value), 8, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadSFixed64(), (ref WriteContext output, long value) => output.WriteSFixed64(value), 8, tag, defaultValue);
}
///
@@ -351,7 +351,7 @@ public static FieldCodec ForSFixed64(uint tag, long defaultValue)
/// A codec for the given tag.
public static FieldCodec ForUInt64(uint tag, ulong defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadUInt64(), (output, value) => output.WriteUInt64(value), CodedOutputStream.ComputeUInt64Size, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadUInt64(), (ref WriteContext output, ulong value) => output.WriteUInt64(value), CodedOutputStream.ComputeUInt64Size, tag, defaultValue);
}
///
@@ -362,7 +362,7 @@ public static FieldCodec ForUInt64(uint tag, ulong defaultValue)
/// A codec for the given tag.
public static FieldCodec ForFloat(uint tag, float defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadFloat(), (output, value) => output.WriteFloat(value), CodedOutputStream.FloatSize, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadFloat(), (ref WriteContext output, float value) => output.WriteFloat(value), CodedOutputStream.FloatSize, tag, defaultValue);
}
///
@@ -373,7 +373,7 @@ public static FieldCodec ForFloat(uint tag, float defaultValue)
/// A codec for the given tag.
public static FieldCodec ForDouble(uint tag, double defaultValue)
{
- return new FieldCodec((ref ParseContext ctx) => ctx.ReadDouble(), (output, value) => output.WriteDouble(value), CodedOutputStream.DoubleSize, tag, defaultValue);
+ return new FieldCodec((ref ParseContext ctx) => ctx.ReadDouble(), (ref WriteContext output, double value) => output.WriteDouble(value), CodedOutputStream.DoubleSize, tag, defaultValue);
}
// Enums are tricky. We can probably use expression trees to build these delegates automatically,
@@ -391,7 +391,7 @@ public static FieldCodec ForEnum(uint tag, Func toInt32, Func((ref ParseContext ctx) => fromInt32(
ctx.ReadEnum()),
- (output, value) => output.WriteEnum(toInt32(value)),
+ (ref WriteContext output, T value) => output.WriteEnum(toInt32(value)),
value => CodedOutputStream.ComputeEnumSize(toInt32(value)), tag, defaultValue);
}
@@ -410,7 +410,7 @@ public static FieldCodec ForMessage(uint tag, MessageParser parser) whe
ctx.ReadMessage(message);
return message;
},
- (output, value) => output.WriteMessage(value),
+ (ref WriteContext output, T value) => output.WriteMessage(value),
(ref ParseContext ctx, ref T v) =>
{
if (v == null)
@@ -455,7 +455,7 @@ public static FieldCodec ForGroup(uint startTag, uint endTag, MessageParse
ctx.ReadGroup(message);
return message;
},
- (output, value) => output.WriteGroup(value),
+ (ref WriteContext output, T value) => output.WriteGroup(value),
(ref ParseContext ctx, ref T v) =>
{
if (v == null)
@@ -492,7 +492,7 @@ public static FieldCodec ForClassWrapper(uint tag) where T : class
var nestedCodec = WrapperCodecs.GetCodec();
return new FieldCodec(
(ref ParseContext ctx) => WrapperCodecs.Read(ref ctx, nestedCodec),
- (output, value) => WrapperCodecs.Write(output, value, nestedCodec),
+ (ref WriteContext output, T value) => WrapperCodecs.Write(ref output, value, nestedCodec),
(ref ParseContext ctx, ref T v) => v = WrapperCodecs.Read(ref ctx, nestedCodec),
(ref T v, T v2) => { v = v2; return v == null; },
value => WrapperCodecs.CalculateSize(value, nestedCodec),
@@ -509,7 +509,7 @@ public static FieldCodec ForClassWrapper(uint tag) where T : class
var nestedCodec = WrapperCodecs.GetCodec();
return new FieldCodec(
WrapperCodecs.GetReader(),
- (output, value) => WrapperCodecs.Write(output, value.Value, nestedCodec),
+ (ref WriteContext output, T? value) => WrapperCodecs.Write(ref output, value.Value, nestedCodec),
(ref ParseContext ctx, ref T? v) => v = WrapperCodecs.Read(ref ctx, nestedCodec),
(ref T? v, T? v2) => { if (v2.HasValue) { v = v2; } return v.HasValue; },
value => value == null ? 0 : WrapperCodecs.CalculateSize(value.Value, nestedCodec),
@@ -616,10 +616,10 @@ internal static T Read(ref ParseContext ctx, FieldCodec codec)
return value;
}
- internal static void Write(CodedOutputStream output, T value, FieldCodec codec)
+ internal static void Write(ref WriteContext ctx, T value, FieldCodec codec)
{
- output.WriteLength(codec.CalculateSizeWithTag(value));
- codec.WriteTagAndValue(output, value);
+ ctx.WriteLength(codec.CalculateSizeWithTag(value));
+ codec.WriteTagAndValue(ref ctx, value);
}
internal static int CalculateSize(T value, FieldCodec codec)
@@ -631,6 +631,7 @@ internal static int CalculateSize(T value, FieldCodec codec)
}
internal delegate TValue ValueReader(ref ParseContext ctx);
+ internal delegate void ValueWriter(ref WriteContext ctx, T value);
///
///
@@ -685,7 +686,7 @@ internal static bool IsPackedRepeatedField(uint tag) =>
///
/// Returns a delegate to write a value (unconditionally) to a coded output stream.
///
- internal Action ValueWriter { get; }
+ internal ValueWriter ValueWriter { get; }
///
/// Returns the size calculator for just a value.
@@ -744,7 +745,7 @@ internal static bool IsPackedRepeatedField(uint tag) =>
internal FieldCodec(
ValueReader reader,
- Action writer,
+ ValueWriter writer,
int fixedSize,
uint tag,
T defaultValue) : this(reader, writer, _ => fixedSize, tag, defaultValue)
@@ -754,7 +755,7 @@ internal FieldCodec(
internal FieldCodec(
ValueReader reader,
- Action writer,
+ ValueWriter writer,
Func sizeCalculator,
uint tag,
T defaultValue) : this(reader, writer, (ref ParseContext ctx, ref T v) => v = reader(ref ctx), (ref T v, T v2) => { v = v2; return true; }, sizeCalculator, tag, 0, defaultValue)
@@ -763,7 +764,7 @@ internal FieldCodec(
internal FieldCodec(
ValueReader reader,
- Action writer,
+ ValueWriter writer,
InputMerger inputMerger,
ValuesMerger valuesMerger,
Func sizeCalculator,
@@ -774,7 +775,7 @@ internal FieldCodec(
internal FieldCodec(
ValueReader reader,
- Action writer,
+ ValueWriter writer,
InputMerger inputMerger,
ValuesMerger valuesMerger,
Func sizeCalculator,
@@ -802,14 +803,41 @@ internal FieldCodec(
/// Write a tag and the given value, *if* the value is not the default.
///
public void WriteTagAndValue(CodedOutputStream output, T value)
+ {
+ WriteContext.Initialize(output, out WriteContext ctx);
+ try
+ {
+ WriteTagAndValue(ref ctx, value);
+ }
+ finally
+ {
+ ctx.CopyStateTo(output);
+ }
+
+
+ //if (!IsDefault(value))
+ //{
+ // output.WriteTag(Tag);
+ // ValueWriter(output, value);
+ // if (EndTag != 0)
+ // {
+ // output.WriteTag(EndTag);
+ // }
+ //}
+ }
+
+ ///
+ /// Write a tag and the given value, *if* the value is not the default.
+ ///
+ public void WriteTagAndValue(ref WriteContext ctx, T value)
{
if (!IsDefault(value))
{
- output.WriteTag(Tag);
- ValueWriter(output, value);
+ ctx.WriteTag(Tag);
+ ValueWriter(ref ctx, value);
if (EndTag != 0)
{
- output.WriteTag(EndTag);
+ ctx.WriteTag(EndTag);
}
}
}
diff --git a/csharp/src/Google.Protobuf/IBufferMessage.cs b/csharp/src/Google.Protobuf/IBufferMessage.cs
index f6d174b3b768..c99a7d79fc02 100644
--- a/csharp/src/Google.Protobuf/IBufferMessage.cs
+++ b/csharp/src/Google.Protobuf/IBufferMessage.cs
@@ -35,7 +35,7 @@ namespace Google.Protobuf
#if GOOGLE_PROTOBUF_SUPPORT_SYSTEM_MEMORY
///
/// Interface for a Protocol Buffers message, supporting
- /// parsing from .
+ /// parsing from and writing to .
///
public interface IBufferMessage : IMessage
{
@@ -44,6 +44,12 @@ public interface IBufferMessage : IMessage
/// Users should never invoke this method directly.
///
void InternalMergeFrom(ref ParseContext ctx);
+
+ ///
+ /// Internal implementation of writing this message to a given write context.
+ /// Users should never invoke this method directly.
+ ///
+ void InternalWriteTo(ref WriteContext ctx);
}
#endif
}
diff --git a/csharp/src/Google.Protobuf/MessageExtensions.cs b/csharp/src/Google.Protobuf/MessageExtensions.cs
index 51e40915c81d..36a9df7286ed 100644
--- a/csharp/src/Google.Protobuf/MessageExtensions.cs
+++ b/csharp/src/Google.Protobuf/MessageExtensions.cs
@@ -33,6 +33,7 @@
using Google.Protobuf.Reflection;
using System.Buffers;
using System.Collections;
+using System;
using System.IO;
using System.Linq;
using System.Security;
@@ -129,7 +130,7 @@ public static void WriteDelimitedTo(this IMessage message, Stream output)
ProtoPreconditions.CheckNotNull(message, "message");
ProtoPreconditions.CheckNotNull(output, "output");
CodedOutputStream codedOutput = new CodedOutputStream(output);
- codedOutput.WriteRawVarint32((uint)message.CalculateSize());
+ codedOutput.WriteLength(message.CalculateSize());
message.WriteTo(codedOutput);
codedOutput.Flush();
}
@@ -145,6 +146,39 @@ public static ByteString ToByteString(this IMessage message)
return ByteString.AttachBytes(message.ToByteArray());
}
+ ///
+ /// Writes the given message data to the given buffer writer in protobuf encoding.
+ ///
+ /// The message to write to the stream.
+ /// The stream to write to.
+ [SecuritySafeCritical]
+ public static void WriteTo(this IMessage message, IBufferWriter output)
+ {
+ ProtoPreconditions.CheckNotNull(message, nameof(message));
+ ProtoPreconditions.CheckNotNull(output, nameof(output));
+
+ WriteContext.Initialize(output, out WriteContext ctx);
+ WritingPrimitivesMessages.WriteRawMessage(ref ctx, message);
+ ctx.Flush();
+ }
+
+ ///
+ /// Writes the given message data to the given span in protobuf encoding.
+ /// The size of the destination span needs to fit the serialized size
+ /// of the message exactly, otherwise an exception is thrown.
+ ///
+ /// The message to write to the stream.
+ /// The span to write to. Size must match size of the message exactly.
+ [SecuritySafeCritical]
+ public static void WriteTo(this IMessage message, Span output)
+ {
+ ProtoPreconditions.CheckNotNull(message, nameof(message));
+
+ WriteContext.Initialize(ref output, out WriteContext ctx);
+ WritingPrimitivesMessages.WriteRawMessage(ref ctx, message);
+ ctx.CheckNoSpaceLeft();
+ }
+
///
/// Checks if all required fields in a message have values set. For proto3 messages, this returns true
///
diff --git a/csharp/src/Google.Protobuf/ParserInternalState.cs b/csharp/src/Google.Protobuf/ParserInternalState.cs
index 4f0500b0a8d3..50d489dfc486 100644
--- a/csharp/src/Google.Protobuf/ParserInternalState.cs
+++ b/csharp/src/Google.Protobuf/ParserInternalState.cs
@@ -47,7 +47,7 @@ namespace Google.Protobuf
// warning: this is a mutable struct, so it needs to be only passed as a ref!
internal struct ParserInternalState
{
- // NOTE: the Span representing the current buffer is kept separate so that this doesn't have to be a ref struct and so it can live
+ // NOTE: the Span representing the current buffer is kept separate so that this doesn't have to be a ref struct and so it can
// be included in CodedInputStream's internal state
///
diff --git a/csharp/src/Google.Protobuf/ParsingPrimitives.cs b/csharp/src/Google.Protobuf/ParsingPrimitives.cs
index 28a19493d40c..ebb40840aa0a 100644
--- a/csharp/src/Google.Protobuf/ParsingPrimitives.cs
+++ b/csharp/src/Google.Protobuf/ParsingPrimitives.cs
@@ -629,7 +629,7 @@ public static string ReadRawString(ref ReadOnlySpan buffer, ref ParserInte
{
fixed (byte* sourceBytes = &MemoryMarshal.GetReference(data))
{
- value = CodedOutputStream.Utf8Encoding.GetString(sourceBytes, length);
+ value = WritingPrimitives.Utf8Encoding.GetString(sourceBytes, length);
}
}
@@ -638,7 +638,7 @@ public static string ReadRawString(ref ReadOnlySpan buffer, ref ParserInte
}
#endif
- var decoder = CodedOutputStream.Utf8Encoding.GetDecoder();
+ var decoder = WritingPrimitives.Utf8Encoding.GetDecoder();
// TODO: even if GOOGLE_PROTOBUF_SUPPORT_FAST_STRING is not supported,
// we could still create a string efficiently by using Utf8Encoding.GetString(byte[] bytes, int index, int count)
@@ -649,7 +649,7 @@ public static string ReadRawString(ref ReadOnlySpan buffer, ref ParserInte
// creating a string from that array might be more efficient than creating a string from the copied bytes.
// Slow path: Build a byte array first then copy it.
- return CodedOutputStream.Utf8Encoding.GetString(ReadRawBytes(ref buffer, ref state, length), 0, length);
+ return WritingPrimitives.Utf8Encoding.GetString(ReadRawBytes(ref buffer, ref state, length), 0, length);
}
[SecuritySafeCritical]
diff --git a/csharp/src/Google.Protobuf/Reflection/Descriptor.cs b/csharp/src/Google.Protobuf/Reflection/Descriptor.cs
index fda56764e0a3..df9222862a8d 100644
--- a/csharp/src/Google.Protobuf/Reflection/Descriptor.cs
+++ b/csharp/src/Google.Protobuf/Reflection/Descriptor.cs
@@ -276,12 +276,26 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
file_.WriteTo(output, _repeated_file_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ file_.WriteTo(ref output, _repeated_file_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -639,6 +653,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasName) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -669,7 +686,44 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasName) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (HasPackage) {
+ output.WriteRawTag(18);
+ output.WriteString(Package);
+ }
+ dependency_.WriteTo(ref output, _repeated_dependency_codec);
+ messageType_.WriteTo(ref output, _repeated_messageType_codec);
+ enumType_.WriteTo(ref output, _repeated_enumType_codec);
+ service_.WriteTo(ref output, _repeated_service_codec);
+ extension_.WriteTo(ref output, _repeated_extension_codec);
+ if (options_ != null) {
+ output.WriteRawTag(66);
+ output.WriteMessage(Options);
+ }
+ if (sourceCodeInfo_ != null) {
+ output.WriteRawTag(74);
+ output.WriteMessage(SourceCodeInfo);
+ }
+ publicDependency_.WriteTo(ref output, _repeated_publicDependency_codec);
+ weakDependency_.WriteTo(ref output, _repeated_weakDependency_codec);
+ if (HasSyntax) {
+ output.WriteRawTag(98);
+ output.WriteString(Syntax);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1102,6 +1156,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasName) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -1121,8 +1178,34 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasName) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ field_.WriteTo(ref output, _repeated_field_codec);
+ nestedType_.WriteTo(ref output, _repeated_nestedType_codec);
+ enumType_.WriteTo(ref output, _repeated_enumType_codec);
+ extensionRange_.WriteTo(ref output, _repeated_extensionRange_codec);
+ extension_.WriteTo(ref output, _repeated_extension_codec);
+ if (options_ != null) {
+ output.WriteRawTag(58);
+ output.WriteMessage(Options);
+ }
+ oneofDecl_.WriteTo(ref output, _repeated_oneofDecl_codec);
+ reservedRange_.WriteTo(ref output, _repeated_reservedRange_codec);
+ reservedName_.WriteTo(ref output, _repeated_reservedName_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1436,6 +1519,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasStart) {
output.WriteRawTag(8);
output.WriteInt32(Start);
@@ -1451,8 +1537,30 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasStart) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Start);
+ }
+ if (HasEnd) {
+ output.WriteRawTag(16);
+ output.WriteInt32(End);
+ }
+ if (options_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(Options);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1689,6 +1797,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasStart) {
output.WriteRawTag(8);
output.WriteInt32(Start);
@@ -1700,8 +1811,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasStart) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Start);
+ }
+ if (HasEnd) {
+ output.WriteRawTag(16);
+ output.WriteInt32(End);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1878,6 +2007,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
if (_extensions != null) {
_extensions.WriteTo(output);
@@ -1885,7 +2017,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -2384,6 +2530,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasName) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -2431,8 +2580,62 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasName) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (HasExtendee) {
+ output.WriteRawTag(18);
+ output.WriteString(Extendee);
+ }
+ if (HasNumber) {
+ output.WriteRawTag(24);
+ output.WriteInt32(Number);
+ }
+ if (HasLabel) {
+ output.WriteRawTag(32);
+ output.WriteEnum((int) Label);
+ }
+ if (HasType) {
+ output.WriteRawTag(40);
+ output.WriteEnum((int) Type);
+ }
+ if (HasTypeName) {
+ output.WriteRawTag(50);
+ output.WriteString(TypeName);
+ }
+ if (HasDefaultValue) {
+ output.WriteRawTag(58);
+ output.WriteString(DefaultValue);
+ }
+ if (options_ != null) {
+ output.WriteRawTag(66);
+ output.WriteMessage(Options);
+ }
+ if (HasOneofIndex) {
+ output.WriteRawTag(72);
+ output.WriteInt32(OneofIndex);
+ }
+ if (HasJsonName) {
+ output.WriteRawTag(82);
+ output.WriteString(JsonName);
+ }
+ if (HasProto3Optional) {
+ output.WriteRawTag(136, 1);
+ output.WriteBool(Proto3Optional);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -2824,6 +3027,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasName) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -2835,8 +3041,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasName) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (options_ != null) {
+ output.WriteRawTag(18);
+ output.WriteMessage(Options);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -3083,6 +3307,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasName) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -3097,8 +3324,29 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasName) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ value_.WriteTo(ref output, _repeated_value_codec);
+ if (options_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(Options);
+ }
+ reservedRange_.WriteTo(ref output, _repeated_reservedRange_codec);
+ reservedName_.WriteTo(ref output, _repeated_reservedName_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -3356,6 +3604,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasStart) {
output.WriteRawTag(8);
output.WriteInt32(Start);
@@ -3367,7 +3618,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasStart) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Start);
+ }
+ if (HasEnd) {
+ output.WriteRawTag(16);
+ output.WriteInt32(End);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -3592,6 +3861,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasName) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -3607,7 +3879,29 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasName) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (HasNumber) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Number);
+ }
+ if (options_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(Options);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -3834,6 +4128,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasName) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -3846,7 +4143,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasName) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ method_.WriteTo(ref output, _repeated_method_codec);
+ if (options_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(Options);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -4174,6 +4490,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasName) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -4201,8 +4520,42 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasName) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (HasInputType) {
+ output.WriteRawTag(18);
+ output.WriteString(InputType);
+ }
+ if (HasOutputType) {
+ output.WriteRawTag(26);
+ output.WriteString(OutputType);
+ }
+ if (options_ != null) {
+ output.WriteRawTag(34);
+ output.WriteMessage(Options);
+ }
+ if (HasClientStreaming) {
+ output.WriteRawTag(40);
+ output.WriteBool(ClientStreaming);
+ }
+ if (HasServerStreaming) {
+ output.WriteRawTag(48);
+ output.WriteBool(ServerStreaming);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -5068,6 +5421,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasJavaPackage) {
output.WriteRawTag(10);
output.WriteString(JavaPackage);
@@ -5155,7 +5511,101 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasJavaPackage) {
+ output.WriteRawTag(10);
+ output.WriteString(JavaPackage);
+ }
+ if (HasJavaOuterClassname) {
+ output.WriteRawTag(66);
+ output.WriteString(JavaOuterClassname);
+ }
+ if (HasOptimizeFor) {
+ output.WriteRawTag(72);
+ output.WriteEnum((int) OptimizeFor);
+ }
+ if (HasJavaMultipleFiles) {
+ output.WriteRawTag(80);
+ output.WriteBool(JavaMultipleFiles);
+ }
+ if (HasGoPackage) {
+ output.WriteRawTag(90);
+ output.WriteString(GoPackage);
+ }
+ if (HasCcGenericServices) {
+ output.WriteRawTag(128, 1);
+ output.WriteBool(CcGenericServices);
+ }
+ if (HasJavaGenericServices) {
+ output.WriteRawTag(136, 1);
+ output.WriteBool(JavaGenericServices);
+ }
+ if (HasPyGenericServices) {
+ output.WriteRawTag(144, 1);
+ output.WriteBool(PyGenericServices);
+ }
+ if (HasJavaGenerateEqualsAndHash) {
+ output.WriteRawTag(160, 1);
+ output.WriteBool(JavaGenerateEqualsAndHash);
+ }
+ if (HasDeprecated) {
+ output.WriteRawTag(184, 1);
+ output.WriteBool(Deprecated);
+ }
+ if (HasJavaStringCheckUtf8) {
+ output.WriteRawTag(216, 1);
+ output.WriteBool(JavaStringCheckUtf8);
+ }
+ if (HasCcEnableArenas) {
+ output.WriteRawTag(248, 1);
+ output.WriteBool(CcEnableArenas);
+ }
+ if (HasObjcClassPrefix) {
+ output.WriteRawTag(162, 2);
+ output.WriteString(ObjcClassPrefix);
+ }
+ if (HasCsharpNamespace) {
+ output.WriteRawTag(170, 2);
+ output.WriteString(CsharpNamespace);
+ }
+ if (HasSwiftPrefix) {
+ output.WriteRawTag(186, 2);
+ output.WriteString(SwiftPrefix);
+ }
+ if (HasPhpClassPrefix) {
+ output.WriteRawTag(194, 2);
+ output.WriteString(PhpClassPrefix);
+ }
+ if (HasPhpNamespace) {
+ output.WriteRawTag(202, 2);
+ output.WriteString(PhpNamespace);
+ }
+ if (HasPhpGenericServices) {
+ output.WriteRawTag(208, 2);
+ output.WriteBool(PhpGenericServices);
+ }
+ if (HasPhpMetadataNamespace) {
+ output.WriteRawTag(226, 2);
+ output.WriteString(PhpMetadataNamespace);
+ }
+ if (HasRubyPackage) {
+ output.WriteRawTag(234, 2);
+ output.WriteString(RubyPackage);
+ }
+ uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -5794,21 +6244,53 @@ public override int GetHashCode() {
if (HasMapEntry) hash ^= MapEntry.GetHashCode();
hash ^= uninterpretedOption_.GetHashCode();
if (_extensions != null) {
- hash ^= _extensions.GetHashCode();
+ hash ^= _extensions.GetHashCode();
+ }
+ if (_unknownFields != null) {
+ hash ^= _unknownFields.GetHashCode();
+ }
+ return hash;
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ public override string ToString() {
+ return pb::JsonFormatter.ToDiagnosticString(this);
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
+ if (HasMessageSetWireFormat) {
+ output.WriteRawTag(8);
+ output.WriteBool(MessageSetWireFormat);
+ }
+ if (HasNoStandardDescriptorAccessor) {
+ output.WriteRawTag(16);
+ output.WriteBool(NoStandardDescriptorAccessor);
+ }
+ if (HasDeprecated) {
+ output.WriteRawTag(24);
+ output.WriteBool(Deprecated);
+ }
+ if (HasMapEntry) {
+ output.WriteRawTag(56);
+ output.WriteBool(MapEntry);
+ }
+ uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(output);
}
if (_unknownFields != null) {
- hash ^= _unknownFields.GetHashCode();
+ _unknownFields.WriteTo(output);
}
- return hash;
- }
-
- [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public override string ToString() {
- return pb::JsonFormatter.ToDiagnosticString(this);
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
- public void WriteTo(pb::CodedOutputStream output) {
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
if (HasMessageSetWireFormat) {
output.WriteRawTag(8);
output.WriteBool(MessageSetWireFormat);
@@ -5825,14 +6307,15 @@ public void WriteTo(pb::CodedOutputStream output) {
output.WriteRawTag(56);
output.WriteBool(MapEntry);
}
- uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
+ uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
if (_extensions != null) {
- _extensions.WriteTo(output);
+ _extensions.WriteTo(ref output);
}
if (_unknownFields != null) {
- _unknownFields.WriteTo(output);
+ _unknownFields.WriteTo(ref output);
}
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6301,6 +6784,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasCtype) {
output.WriteRawTag(8);
output.WriteEnum((int) Ctype);
@@ -6332,7 +6818,45 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasCtype) {
+ output.WriteRawTag(8);
+ output.WriteEnum((int) Ctype);
+ }
+ if (HasPacked) {
+ output.WriteRawTag(16);
+ output.WriteBool(Packed);
+ }
+ if (HasDeprecated) {
+ output.WriteRawTag(24);
+ output.WriteBool(Deprecated);
+ }
+ if (HasLazy) {
+ output.WriteRawTag(40);
+ output.WriteBool(Lazy);
+ }
+ if (HasJstype) {
+ output.WriteRawTag(48);
+ output.WriteEnum((int) Jstype);
+ }
+ if (HasWeak) {
+ output.WriteRawTag(80);
+ output.WriteBool(Weak);
+ }
+ uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6632,6 +7156,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
uninterpretedOption_.WriteTo(output, _repeated_uninterpretedOption_codec);
if (_extensions != null) {
_extensions.WriteTo(output);
@@ -6639,7 +7166,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -6890,6 +7431,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasAllowAlias) {
output.WriteRawTag(16);
output.WriteBool(AllowAlias);
@@ -6905,7 +7449,29 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasAllowAlias) {
+ output.WriteRawTag(16);
+ output.WriteBool(AllowAlias);
+ }
+ if (HasDeprecated) {
+ output.WriteRawTag(24);
+ output.WriteBool(Deprecated);
+ }
+ uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -7153,6 +7719,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasDeprecated) {
output.WriteRawTag(8);
output.WriteBool(Deprecated);
@@ -7164,7 +7733,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasDeprecated) {
+ output.WriteRawTag(8);
+ output.WriteBool(Deprecated);
+ }
+ uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -7398,6 +7985,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasDeprecated) {
output.WriteRawTag(136, 2);
output.WriteBool(Deprecated);
@@ -7409,7 +7999,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasDeprecated) {
+ output.WriteRawTag(136, 2);
+ output.WriteBool(Deprecated);
+ }
+ uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -7670,6 +8278,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasDeprecated) {
output.WriteRawTag(136, 2);
output.WriteBool(Deprecated);
@@ -7685,7 +8296,29 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasDeprecated) {
+ output.WriteRawTag(136, 2);
+ output.WriteBool(Deprecated);
+ }
+ if (HasIdempotencyLevel) {
+ output.WriteRawTag(144, 2);
+ output.WriteEnum((int) IdempotencyLevel);
+ }
+ uninterpretedOption_.WriteTo(ref output, _repeated_uninterpretedOption_codec);
+ if (_extensions != null) {
+ _extensions.WriteTo(ref output);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8083,6 +8716,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
name_.WriteTo(output, _repeated_name_codec);
if (HasIdentifierValue) {
output.WriteRawTag(26);
@@ -8111,7 +8747,42 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ name_.WriteTo(ref output, _repeated_name_codec);
+ if (HasIdentifierValue) {
+ output.WriteRawTag(26);
+ output.WriteString(IdentifierValue);
+ }
+ if (HasPositiveIntValue) {
+ output.WriteRawTag(32);
+ output.WriteUInt64(PositiveIntValue);
+ }
+ if (HasNegativeIntValue) {
+ output.WriteRawTag(40);
+ output.WriteInt64(NegativeIntValue);
+ }
+ if (HasDoubleValue) {
+ output.WriteRawTag(49);
+ output.WriteDouble(DoubleValue);
+ }
+ if (HasStringValue) {
+ output.WriteRawTag(58);
+ output.WriteBytes(StringValue);
+ }
+ if (HasAggregateValue) {
+ output.WriteRawTag(66);
+ output.WriteString(AggregateValue);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8389,6 +9060,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (HasNamePart_) {
output.WriteRawTag(10);
output.WriteString(NamePart_);
@@ -8400,7 +9074,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (HasNamePart_) {
+ output.WriteRawTag(10);
+ output.WriteString(NamePart_);
+ }
+ if (HasIsExtension) {
+ output.WriteRawTag(16);
+ output.WriteBool(IsExtension);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8615,11 +9307,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
location_.WriteTo(output, _repeated_location_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ location_.WriteTo(ref output, _repeated_location_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -8923,6 +9629,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
path_.WriteTo(output, _repeated_path_codec);
span_.WriteTo(output, _repeated_span_codec);
if (HasLeadingComments) {
@@ -8937,7 +9646,28 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ path_.WriteTo(ref output, _repeated_path_codec);
+ span_.WriteTo(ref output, _repeated_span_codec);
+ if (HasLeadingComments) {
+ output.WriteRawTag(26);
+ output.WriteString(LeadingComments);
+ }
+ if (HasTrailingComments) {
+ output.WriteRawTag(34);
+ output.WriteString(TrailingComments);
+ }
+ leadingDetachedComments_.WriteTo(ref output, _repeated_leadingDetachedComments_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -9146,11 +9876,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
annotation_.WriteTo(output, _repeated_annotation_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ annotation_.WriteTo(ref output, _repeated_annotation_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -9393,6 +10137,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
path_.WriteTo(output, _repeated_path_codec);
if (HasSourceFile) {
output.WriteRawTag(18);
@@ -9409,7 +10156,30 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ path_.WriteTo(ref output, _repeated_path_codec);
+ if (HasSourceFile) {
+ output.WriteRawTag(18);
+ output.WriteString(SourceFile);
+ }
+ if (HasBegin) {
+ output.WriteRawTag(24);
+ output.WriteInt32(Begin);
+ }
+ if (HasEnd) {
+ output.WriteRawTag(32);
+ output.WriteInt32(End);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf/UnknownField.cs b/csharp/src/Google.Protobuf/UnknownField.cs
index e3ce0e86efce..63d89604a2ef 100644
--- a/csharp/src/Google.Protobuf/UnknownField.cs
+++ b/csharp/src/Google.Protobuf/UnknownField.cs
@@ -101,8 +101,8 @@ public override int GetHashCode()
///
///
/// The unknown field number.
- /// The CodedOutputStream to write to.
- internal void WriteTo(int fieldNumber, CodedOutputStream output)
+ /// The write context to write to.
+ internal void WriteTo(int fieldNumber, ref WriteContext output)
{
if (varintList != null)
{
@@ -141,7 +141,7 @@ internal void WriteTo(int fieldNumber, CodedOutputStream output)
foreach (UnknownFieldSet value in groupList)
{
output.WriteTag(fieldNumber, WireFormat.WireType.StartGroup);
- value.WriteTo(output);
+ value.WriteTo(ref output);
output.WriteTag(fieldNumber, WireFormat.WireType.EndGroup);
}
}
diff --git a/csharp/src/Google.Protobuf/UnknownFieldSet.cs b/csharp/src/Google.Protobuf/UnknownFieldSet.cs
index 9ebe70406598..9888dd1c3d09 100644
--- a/csharp/src/Google.Protobuf/UnknownFieldSet.cs
+++ b/csharp/src/Google.Protobuf/UnknownFieldSet.cs
@@ -71,10 +71,27 @@ internal bool HasField(int field)
/// Serializes the set and writes it to .
///
public void WriteTo(CodedOutputStream output)
+ {
+ WriteContext.Initialize(output, out WriteContext ctx);
+ try
+ {
+ WriteTo(ref ctx);
+ }
+ finally
+ {
+ ctx.CopyStateTo(output);
+ }
+ }
+
+ ///
+ /// Serializes the set and writes it to .
+ ///
+ [SecuritySafeCritical]
+ public void WriteTo(ref WriteContext ctx)
{
foreach (KeyValuePair entry in fields)
{
- entry.Value.WriteTo(entry.Key, output);
+ entry.Value.WriteTo(entry.Key, ref ctx);
}
}
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/Any.cs b/csharp/src/Google.Protobuf/WellKnownTypes/Any.cs
index fc23560f8af5..2b33cd459b4b 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/Any.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/Any.cs
@@ -248,6 +248,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (TypeUrl.Length != 0) {
output.WriteRawTag(10);
output.WriteString(TypeUrl);
@@ -259,7 +262,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (TypeUrl.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(TypeUrl);
+ }
+ if (Value.Length != 0) {
+ output.WriteRawTag(18);
+ output.WriteBytes(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/Api.cs b/csharp/src/Google.Protobuf/WellKnownTypes/Api.cs
index e8f1a50e29e2..6bc0821fa5f6 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/Api.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/Api.cs
@@ -269,6 +269,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -291,8 +294,37 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ methods_.WriteTo(ref output, _repeated_methods_codec);
+ options_.WriteTo(ref output, _repeated_options_codec);
+ if (Version.Length != 0) {
+ output.WriteRawTag(34);
+ output.WriteString(Version);
+ }
+ if (sourceContext_ != null) {
+ output.WriteRawTag(42);
+ output.WriteMessage(SourceContext);
+ }
+ mixins_.WriteTo(ref output, _repeated_mixins_codec);
+ if (Syntax != global::Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+ output.WriteRawTag(56);
+ output.WriteEnum((int) Syntax);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -627,6 +659,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -655,7 +690,42 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (RequestTypeUrl.Length != 0) {
+ output.WriteRawTag(18);
+ output.WriteString(RequestTypeUrl);
+ }
+ if (RequestStreaming != false) {
+ output.WriteRawTag(24);
+ output.WriteBool(RequestStreaming);
+ }
+ if (ResponseTypeUrl.Length != 0) {
+ output.WriteRawTag(34);
+ output.WriteString(ResponseTypeUrl);
+ }
+ if (ResponseStreaming != false) {
+ output.WriteRawTag(40);
+ output.WriteBool(ResponseStreaming);
+ }
+ options_.WriteTo(ref output, _repeated_options_codec);
+ if (Syntax != global::Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+ output.WriteRawTag(56);
+ output.WriteEnum((int) Syntax);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -984,6 +1054,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -995,8 +1068,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (Root.Length != 0) {
+ output.WriteRawTag(18);
+ output.WriteString(Root);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/Duration.cs b/csharp/src/Google.Protobuf/WellKnownTypes/Duration.cs
index 8ef1b3778b27..2d479badcbb5 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/Duration.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/Duration.cs
@@ -210,6 +210,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Seconds != 0L) {
output.WriteRawTag(8);
output.WriteInt64(Seconds);
@@ -221,7 +224,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Seconds != 0L) {
+ output.WriteRawTag(8);
+ output.WriteInt64(Seconds);
+ }
+ if (Nanos != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Nanos);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/Empty.cs b/csharp/src/Google.Protobuf/WellKnownTypes/Empty.cs
index ff04940390cc..ce820cbc91c3 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/Empty.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/Empty.cs
@@ -119,10 +119,23 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/FieldMask.cs b/csharp/src/Google.Protobuf/WellKnownTypes/FieldMask.cs
index 72c049f709af..ee53861f9047 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/FieldMask.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/FieldMask.cs
@@ -325,11 +325,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
paths_.WriteTo(output, _repeated_paths_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ paths_.WriteTo(ref output, _repeated_paths_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/SourceContext.cs b/csharp/src/Google.Protobuf/WellKnownTypes/SourceContext.cs
index dbfc8a99c8db..38240bb61531 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/SourceContext.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/SourceContext.cs
@@ -131,6 +131,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (FileName.Length != 0) {
output.WriteRawTag(10);
output.WriteString(FileName);
@@ -138,7 +141,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (FileName.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(FileName);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/Struct.cs b/csharp/src/Google.Protobuf/WellKnownTypes/Struct.cs
index 2ba1b1cc5c1f..42d37ca01bbf 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/Struct.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/Struct.cs
@@ -162,11 +162,25 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
fields_.WriteTo(output, _map_fields_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ fields_.WriteTo(ref output, _map_fields_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -446,6 +460,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (kindCase_ == KindOneofCase.NullValue) {
output.WriteRawTag(8);
output.WriteEnum((int) NullValue);
@@ -473,7 +490,41 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (kindCase_ == KindOneofCase.NullValue) {
+ output.WriteRawTag(8);
+ output.WriteEnum((int) NullValue);
+ }
+ if (kindCase_ == KindOneofCase.NumberValue) {
+ output.WriteRawTag(17);
+ output.WriteDouble(NumberValue);
+ }
+ if (kindCase_ == KindOneofCase.StringValue) {
+ output.WriteRawTag(26);
+ output.WriteString(StringValue);
+ }
+ if (kindCase_ == KindOneofCase.BoolValue) {
+ output.WriteRawTag(32);
+ output.WriteBool(BoolValue);
+ }
+ if (kindCase_ == KindOneofCase.StructValue) {
+ output.WriteRawTag(42);
+ output.WriteMessage(StructValue);
+ }
+ if (kindCase_ == KindOneofCase.ListValue) {
+ output.WriteRawTag(50);
+ output.WriteMessage(ListValue);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -729,12 +780,26 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
values_.WriteTo(output, _repeated_values_codec);
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ values_.WriteTo(ref output, _repeated_values_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/Timestamp.cs b/csharp/src/Google.Protobuf/WellKnownTypes/Timestamp.cs
index 208cd26fe7ef..b2f5d35335bb 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/Timestamp.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/Timestamp.cs
@@ -231,6 +231,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Seconds != 0L) {
output.WriteRawTag(8);
output.WriteInt64(Seconds);
@@ -242,7 +245,25 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Seconds != 0L) {
+ output.WriteRawTag(8);
+ output.WriteInt64(Seconds);
+ }
+ if (Nanos != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Nanos);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/Type.cs b/csharp/src/Google.Protobuf/WellKnownTypes/Type.cs
index 453ff8dd6de6..c62095a98721 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/Type.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/Type.cs
@@ -262,6 +262,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -280,7 +283,32 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ fields_.WriteTo(ref output, _repeated_fields_codec);
+ oneofs_.WriteTo(ref output, _repeated_oneofs_codec);
+ options_.WriteTo(ref output, _repeated_options_codec);
+ if (sourceContext_ != null) {
+ output.WriteRawTag(42);
+ output.WriteMessage(SourceContext);
+ }
+ if (Syntax != global::Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+ output.WriteRawTag(48);
+ output.WriteEnum((int) Syntax);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -655,6 +683,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Kind != global::Google.Protobuf.WellKnownTypes.Field.Types.Kind.TypeUnknown) {
output.WriteRawTag(8);
output.WriteEnum((int) Kind);
@@ -695,7 +726,54 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Kind != global::Google.Protobuf.WellKnownTypes.Field.Types.Kind.TypeUnknown) {
+ output.WriteRawTag(8);
+ output.WriteEnum((int) Kind);
+ }
+ if (Cardinality != global::Google.Protobuf.WellKnownTypes.Field.Types.Cardinality.Unknown) {
+ output.WriteRawTag(16);
+ output.WriteEnum((int) Cardinality);
+ }
+ if (Number != 0) {
+ output.WriteRawTag(24);
+ output.WriteInt32(Number);
+ }
+ if (Name.Length != 0) {
+ output.WriteRawTag(34);
+ output.WriteString(Name);
+ }
+ if (TypeUrl.Length != 0) {
+ output.WriteRawTag(50);
+ output.WriteString(TypeUrl);
+ }
+ if (OneofIndex != 0) {
+ output.WriteRawTag(56);
+ output.WriteInt32(OneofIndex);
+ }
+ if (Packed != false) {
+ output.WriteRawTag(64);
+ output.WriteBool(Packed);
+ }
+ options_.WriteTo(ref output, _repeated_options_codec);
+ if (JsonName.Length != 0) {
+ output.WriteRawTag(82);
+ output.WriteString(JsonName);
+ }
+ if (DefaultValue.Length != 0) {
+ output.WriteRawTag(90);
+ output.WriteString(DefaultValue);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1148,6 +1226,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -1165,7 +1246,31 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ enumvalue_.WriteTo(ref output, _repeated_enumvalue_codec);
+ options_.WriteTo(ref output, _repeated_options_codec);
+ if (sourceContext_ != null) {
+ output.WriteRawTag(34);
+ output.WriteMessage(SourceContext);
+ }
+ if (Syntax != global::Google.Protobuf.WellKnownTypes.Syntax.Proto2) {
+ output.WriteRawTag(40);
+ output.WriteEnum((int) Syntax);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1409,6 +1514,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -1421,8 +1529,27 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (Number != 0) {
+ output.WriteRawTag(16);
+ output.WriteInt32(Number);
+ }
+ options_.WriteTo(ref output, _repeated_options_codec);
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1623,6 +1750,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Name.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Name);
@@ -1634,8 +1764,26 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Name.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Name);
+ }
+ if (value_ != null) {
+ output.WriteRawTag(18);
+ output.WriteMessage(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf/WellKnownTypes/Wrappers.cs b/csharp/src/Google.Protobuf/WellKnownTypes/Wrappers.cs
index fa3458cf3d38..5bf47dcb0d33 100644
--- a/csharp/src/Google.Protobuf/WellKnownTypes/Wrappers.cs
+++ b/csharp/src/Google.Protobuf/WellKnownTypes/Wrappers.cs
@@ -143,6 +143,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value != 0D) {
output.WriteRawTag(9);
output.WriteDouble(Value);
@@ -150,7 +153,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value != 0D) {
+ output.WriteRawTag(9);
+ output.WriteDouble(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -306,6 +323,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value != 0F) {
output.WriteRawTag(13);
output.WriteFloat(Value);
@@ -313,7 +333,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value != 0F) {
+ output.WriteRawTag(13);
+ output.WriteFloat(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -469,6 +503,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value != 0L) {
output.WriteRawTag(8);
output.WriteInt64(Value);
@@ -476,8 +513,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value != 0L) {
+ output.WriteRawTag(8);
+ output.WriteInt64(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -632,6 +683,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value != 0UL) {
output.WriteRawTag(8);
output.WriteUInt64(Value);
@@ -639,8 +693,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value != 0UL) {
+ output.WriteRawTag(8);
+ output.WriteUInt64(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -795,6 +863,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value != 0) {
output.WriteRawTag(8);
output.WriteInt32(Value);
@@ -802,7 +873,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value != 0) {
+ output.WriteRawTag(8);
+ output.WriteInt32(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -958,6 +1043,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value != 0) {
output.WriteRawTag(8);
output.WriteUInt32(Value);
@@ -965,7 +1053,21 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
+ }
+
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value != 0) {
+ output.WriteRawTag(8);
+ output.WriteUInt32(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
}
+ #endif
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
@@ -1121,6 +1223,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value != false) {
output.WriteRawTag(8);
output.WriteBool(Value);
@@ -1128,8 +1233,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value != false) {
+ output.WriteRawTag(8);
+ output.WriteBool(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1284,6 +1403,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value.Length != 0) {
output.WriteRawTag(10);
output.WriteString(Value);
@@ -1291,8 +1413,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteString(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
@@ -1447,6 +1583,9 @@ public override string ToString() {
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public void WriteTo(pb::CodedOutputStream output) {
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ output.WriteRawMessage(this);
+ #else
if (Value.Length != 0) {
output.WriteRawTag(10);
output.WriteBytes(Value);
@@ -1454,8 +1593,22 @@ public void WriteTo(pb::CodedOutputStream output) {
if (_unknownFields != null) {
_unknownFields.WriteTo(output);
}
+ #endif
}
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
+ void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
+ if (Value.Length != 0) {
+ output.WriteRawTag(10);
+ output.WriteBytes(Value);
+ }
+ if (_unknownFields != null) {
+ _unknownFields.WriteTo(ref output);
+ }
+ }
+ #endif
+
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public int CalculateSize() {
int size = 0;
diff --git a/csharp/src/Google.Protobuf/WriteBufferHelper.cs b/csharp/src/Google.Protobuf/WriteBufferHelper.cs
new file mode 100644
index 000000000000..f2a59bc56f44
--- /dev/null
+++ b/csharp/src/Google.Protobuf/WriteBufferHelper.cs
@@ -0,0 +1,166 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Security;
+
+namespace Google.Protobuf
+{
+ ///
+ /// Abstraction for writing to a steam / IBufferWriter
+ ///
+ [SecuritySafeCritical]
+ internal struct WriteBufferHelper
+ {
+ private IBufferWriter bufferWriter;
+ private CodedOutputStream codedOutputStream;
+
+ public CodedOutputStream CodedOutputStream => codedOutputStream;
+
+ ///
+ /// Initialize an instance with a coded output stream.
+ /// This approach is faster than using a constructor because the instance to initialize is passed by reference
+ /// and we can write directly into it without copying.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static void Initialize(CodedOutputStream codedOutputStream, out WriteBufferHelper instance)
+ {
+ instance.bufferWriter = null;
+ instance.codedOutputStream = codedOutputStream;
+ }
+
+ ///
+ /// Initialize an instance with a buffer writer.
+ /// This approach is faster than using a constructor because the instance to initialize is passed by reference
+ /// and we can write directly into it without copying.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static void Initialize(IBufferWriter bufferWriter, out WriteBufferHelper instance, out Span buffer)
+ {
+ instance.bufferWriter = bufferWriter;
+ instance.codedOutputStream = null;
+ buffer = default; // TODO: initialize the initial buffer so that the first write is not via slowpath.
+ }
+
+ ///
+ /// Initialize an instance with a buffer represented by a single span (i.e. buffer cannot be refreshed)
+ /// This approach is faster than using a constructor because the instance to initialize is passed by reference
+ /// and we can write directly into it without copying.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static void InitializeNonRefreshable(out WriteBufferHelper instance)
+ {
+ instance.bufferWriter = null;
+ instance.codedOutputStream = null;
+ }
+
+ ///
+ /// Verifies that SpaceLeft returns zero.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static void CheckNoSpaceLeft(ref WriterInternalState state)
+ {
+ if (GetSpaceLeft(ref state) != 0)
+ {
+ throw new InvalidOperationException("Did not write as much data as expected.");
+ }
+ }
+
+ ///
+ /// If writing to a flat array, returns the space left in the array. Otherwise,
+ /// throws an InvalidOperationException.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static int GetSpaceLeft(ref WriterInternalState state)
+ {
+ if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream == null && state.writeBufferHelper.bufferWriter == null)
+ {
+ return state.limit - state.position;
+ }
+ else
+ {
+ throw new InvalidOperationException(
+ "SpaceLeft can only be called on CodedOutputStreams that are " +
+ "writing to a flat array or when writing to a single span.");
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void RefreshBuffer(ref Span buffer, ref WriterInternalState state)
+ {
+ if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream != null)
+ {
+ // because we're using coded output stream, we know that "buffer" and codedOutputStream.InternalBuffer are identical.
+ state.writeBufferHelper.codedOutputStream.InternalOutputStream.Write(state.writeBufferHelper.codedOutputStream.InternalBuffer, 0, state.position);
+ // reset position, limit stays the same because we are reusing the codedOutputStream's internal buffer.
+ state.position = 0;
+ }
+ else if (state.writeBufferHelper.bufferWriter != null)
+ {
+ // commit the bytes and get a new buffer to write to.
+ state.writeBufferHelper.bufferWriter.Advance(state.position);
+ state.position = 0;
+ buffer = state.writeBufferHelper.bufferWriter.GetSpan();
+ state.limit = buffer.Length;
+ }
+ else
+ {
+ // We're writing to a single buffer.
+ throw new CodedOutputStream.OutOfSpaceException();
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static void Flush(ref Span buffer, ref WriterInternalState state)
+ {
+ if (state.writeBufferHelper.codedOutputStream?.InternalOutputStream != null)
+ {
+ // because we're using coded output stream, we know that "buffer" and codedOutputStream.InternalBuffer are identical.
+ state.writeBufferHelper.codedOutputStream.InternalOutputStream.Write(state.writeBufferHelper.codedOutputStream.InternalBuffer, 0, state.position);
+ state.position = 0;
+ }
+ else if (state.writeBufferHelper.bufferWriter != null)
+ {
+ // calling Advance invalidates the current buffer and we must not continue writing to it,
+ // so we set the current buffer to point to an empty Span. If any subsequent writes happen,
+ // the first subsequent write will trigger refresing of the buffer.
+ state.writeBufferHelper.bufferWriter.Advance(state.position);
+ state.position = 0;
+ state.limit = 0;
+ buffer = default; // invalidate the current buffer
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/csharp/src/Google.Protobuf/WriteContext.cs b/csharp/src/Google.Protobuf/WriteContext.cs
new file mode 100644
index 000000000000..e822e1d6da4c
--- /dev/null
+++ b/csharp/src/Google.Protobuf/WriteContext.cs
@@ -0,0 +1,371 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using Google.Protobuf.Collections;
+
+namespace Google.Protobuf
+{
+ ///
+ /// An opaque struct that represents the current serialization state and is passed along
+ /// as the serialization proceeds.
+ /// All the public methods are intended to be invoked only by the generated code,
+ /// users should never invoke them directly.
+ ///
+ [SecuritySafeCritical]
+ public ref struct WriteContext
+ {
+ internal Span buffer;
+ internal WriterInternalState state;
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ internal static void Initialize(ref Span buffer, ref WriterInternalState state, out WriteContext ctx)
+ {
+ ctx.buffer = buffer;
+ ctx.state = state;
+ }
+
+ ///
+ /// Creates a WriteContext instance from CodedOutputStream.
+ /// WARNING: internally this copies the CodedOutputStream's state, so after done with the WriteContext,
+ /// the CodedOutputStream's state needs to be updated.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ internal static void Initialize(CodedOutputStream output, out WriteContext ctx)
+ {
+ ctx.buffer = new Span(output.InternalBuffer);
+ // ideally we would use a reference to the original state, but that doesn't seem possible
+ // so we just copy the struct that holds the state. We will need to later store the state back
+ // into CodedOutputStream if we want to keep it usable.
+ ctx.state = output.InternalState;
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ internal static void Initialize(IBufferWriter output, out WriteContext ctx)
+ {
+ ctx.buffer = default;
+ ctx.state = default;
+ WriteBufferHelper.Initialize(output, out ctx.state.writeBufferHelper, out ctx.buffer);
+ ctx.state.limit = ctx.buffer.Length;
+ ctx.state.position = 0;
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ internal static void Initialize(ref Span buffer, out WriteContext ctx)
+ {
+ ctx.buffer = buffer;
+ ctx.state = default;
+ ctx.state.limit = ctx.buffer.Length;
+ ctx.state.position = 0;
+ WriteBufferHelper.InitializeNonRefreshable(out ctx.state.writeBufferHelper);
+ }
+
+ ///
+ /// Writes a double field value, without a tag.
+ ///
+ /// The value to write
+ public void WriteDouble(double value)
+ {
+ WritingPrimitives.WriteDouble(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a float field value, without a tag.
+ ///
+ /// The value to write
+ public void WriteFloat(float value)
+ {
+ WritingPrimitives.WriteFloat(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a uint64 field value, without a tag.
+ ///
+ /// The value to write
+ public void WriteUInt64(ulong value)
+ {
+ WritingPrimitives.WriteUInt64(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an int64 field value, without a tag.
+ ///
+ /// The value to write
+ public void WriteInt64(long value)
+ {
+ WritingPrimitives.WriteInt64(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an int32 field value, without a tag.
+ ///
+ /// The value to write
+ public void WriteInt32(int value)
+ {
+ WritingPrimitives.WriteInt32(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a fixed64 field value, without a tag.
+ ///
+ /// The value to write
+ public void WriteFixed64(ulong value)
+ {
+ WritingPrimitives.WriteFixed64(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a fixed32 field value, without a tag.
+ ///
+ /// The value to write
+ public void WriteFixed32(uint value)
+ {
+ WritingPrimitives.WriteFixed32(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a bool field value, without a tag.
+ ///
+ /// The value to write
+ public void WriteBool(bool value)
+ {
+ WritingPrimitives.WriteBool(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a string field value, without a tag.
+ /// The data is length-prefixed.
+ ///
+ /// The value to write
+ public void WriteString(string value)
+ {
+ WritingPrimitives.WriteString(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a message, without a tag.
+ /// The data is length-prefixed.
+ ///
+ /// The value to write
+ public void WriteMessage(IMessage value)
+ {
+ WritingPrimitivesMessages.WriteMessage(ref this, value);
+ }
+
+ ///
+ /// Writes a group, without a tag, to the stream.
+ ///
+ /// The value to write
+ public void WriteGroup(IMessage value)
+ {
+ WritingPrimitivesMessages.WriteGroup(ref this, value);
+ }
+
+ ///
+ /// Write a byte string, without a tag, to the stream.
+ /// The data is length-prefixed.
+ ///
+ /// The value to write
+ public void WriteBytes(ByteString value)
+ {
+ WritingPrimitives.WriteBytes(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a uint32 value, without a tag.
+ ///
+ /// The value to write
+ public void WriteUInt32(uint value)
+ {
+ WritingPrimitives.WriteUInt32(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an enum value, without a tag.
+ ///
+ /// The value to write
+ public void WriteEnum(int value)
+ {
+ WritingPrimitives.WriteEnum(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an sfixed32 value, without a tag.
+ ///
+ /// The value to write.
+ public void WriteSFixed32(int value)
+ {
+ WritingPrimitives.WriteSFixed32(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an sfixed64 value, without a tag.
+ ///
+ /// The value to write
+ public void WriteSFixed64(long value)
+ {
+ WritingPrimitives.WriteSFixed64(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an sint32 value, without a tag.
+ ///
+ /// The value to write
+ public void WriteSInt32(int value)
+ {
+ WritingPrimitives.WriteSInt32(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an sint64 value, without a tag.
+ ///
+ /// The value to write
+ public void WriteSInt64(long value)
+ {
+ WritingPrimitives.WriteSInt64(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a length (in bytes) for length-delimited data.
+ ///
+ ///
+ /// This method simply writes a rawint, but exists for clarity in calling code.
+ ///
+ /// Length value, in bytes.
+ public void WriteLength(int length)
+ {
+ WritingPrimitives.WriteLength(ref buffer, ref state, length);
+ }
+
+ ///
+ /// Encodes and writes a tag.
+ ///
+ /// The number of the field to write the tag for
+ /// The wire format type of the tag to write
+ public void WriteTag(int fieldNumber, WireFormat.WireType type)
+ {
+ WritingPrimitives.WriteTag(ref buffer, ref state, fieldNumber, type);
+ }
+
+ ///
+ /// Writes an already-encoded tag.
+ ///
+ /// The encoded tag
+ public void WriteTag(uint tag)
+ {
+ WritingPrimitives.WriteTag(ref buffer, ref state, tag);
+ }
+
+ ///
+ /// Writes the given single-byte tag.
+ ///
+ /// The encoded tag
+ public void WriteRawTag(byte b1)
+ {
+ WritingPrimitives.WriteRawTag(ref buffer, ref state, b1);
+ }
+
+ ///
+ /// Writes the given two-byte tag.
+ ///
+ /// The first byte of the encoded tag
+ /// The second byte of the encoded tag
+ public void WriteRawTag(byte b1, byte b2)
+ {
+ WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2);
+ }
+
+ ///
+ /// Writes the given three-byte tag.
+ ///
+ /// The first byte of the encoded tag
+ /// The second byte of the encoded tag
+ /// The third byte of the encoded tag
+ public void WriteRawTag(byte b1, byte b2, byte b3)
+ {
+ WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2, b3);
+ }
+
+ ///
+ /// Writes the given four-byte tag.
+ ///
+ /// The first byte of the encoded tag
+ /// The second byte of the encoded tag
+ /// The third byte of the encoded tag
+ /// The fourth byte of the encoded tag
+ public void WriteRawTag(byte b1, byte b2, byte b3, byte b4)
+ {
+ WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2, b3, b4);
+ }
+
+ ///
+ /// Writes the given five-byte tag.
+ ///
+ /// The first byte of the encoded tag
+ /// The second byte of the encoded tag
+ /// The third byte of the encoded tag
+ /// The fourth byte of the encoded tag
+ /// The fifth byte of the encoded tag
+ public void WriteRawTag(byte b1, byte b2, byte b3, byte b4, byte b5)
+ {
+ WritingPrimitives.WriteRawTag(ref buffer, ref state, b1, b2, b3, b4, b5);
+ }
+
+ internal void Flush()
+ {
+ WriteBufferHelper.Flush(ref buffer, ref state);
+ }
+
+ internal void CheckNoSpaceLeft()
+ {
+ WriteBufferHelper.CheckNoSpaceLeft(ref state);
+ }
+
+ internal void CopyStateTo(CodedOutputStream output)
+ {
+ output.InternalState = state;
+ }
+
+ internal void LoadStateFrom(CodedOutputStream output)
+ {
+ state = output.InternalState;
+ }
+ }
+}
\ No newline at end of file
diff --git a/csharp/src/Google.Protobuf/WriterInternalState.cs b/csharp/src/Google.Protobuf/WriterInternalState.cs
new file mode 100644
index 000000000000..a779305bb730
--- /dev/null
+++ b/csharp/src/Google.Protobuf/WriterInternalState.cs
@@ -0,0 +1,62 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+using Google.Protobuf.Collections;
+
+namespace Google.Protobuf
+{
+
+ // warning: this is a mutable struct, so it needs to be only passed as a ref!
+ internal struct WriterInternalState
+ {
+ // NOTE: the Span representing the current buffer is kept separate so that this doesn't have to be a ref struct and so it can
+ // be included in CodedOutputStream's internal state
+
+ internal int limit; // the size of the current buffer
+ internal int position; // position in the current buffer
+
+ internal WriteBufferHelper writeBufferHelper;
+
+ // If non-null, the top level parse method was started with given coded output stream as an argument
+ // which also means we can potentially fallback to calling WriteTo(CodedOutputStream cos) if needed.
+ internal CodedOutputStream CodedOutputStream => writeBufferHelper.CodedOutputStream;
+ }
+}
\ No newline at end of file
diff --git a/csharp/src/Google.Protobuf/WritingPrimitives.cs b/csharp/src/Google.Protobuf/WritingPrimitives.cs
new file mode 100644
index 000000000000..4ccad7376deb
--- /dev/null
+++ b/csharp/src/Google.Protobuf/WritingPrimitives.cs
@@ -0,0 +1,638 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Text;
+
+namespace Google.Protobuf
+{
+ ///
+ /// Primitives for encoding protobuf wire format.
+ ///
+ [SecuritySafeCritical]
+ internal static class WritingPrimitives
+ {
+ // "Local" copy of Encoding.UTF8, for efficiency. (Yes, it makes a difference.)
+ internal static readonly Encoding Utf8Encoding = Encoding.UTF8;
+
+ #region Writing of values (not including tags)
+
+ ///
+ /// Writes a double field value, without a tag, to the stream.
+ ///
+ public static void WriteDouble(ref Span buffer, ref WriterInternalState state, double value)
+ {
+ WriteRawLittleEndian64(ref buffer, ref state, (ulong)BitConverter.DoubleToInt64Bits(value));
+ }
+
+ ///
+ /// Writes a float field value, without a tag, to the stream.
+ ///
+ public static unsafe void WriteFloat(ref Span buffer, ref WriterInternalState state, float value)
+ {
+ const int length = sizeof(float);
+ if (buffer.Length - state.position >= length)
+ {
+ // if there's enough space in the buffer, write the float directly into the buffer
+ var floatSpan = buffer.Slice(state.position, length);
+ Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(floatSpan), value);
+
+ if (!BitConverter.IsLittleEndian)
+ {
+ floatSpan.Reverse();
+ }
+ state.position += length;
+ }
+ else
+ {
+ WriteFloatSlowPath(ref buffer, ref state, value);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private static unsafe void WriteFloatSlowPath(ref Span buffer, ref WriterInternalState state, float value)
+ {
+ const int length = sizeof(float);
+
+ // TODO(jtattermusch): deduplicate the code. Populating the span is the same as for the fastpath.
+ Span floatSpan = stackalloc byte[length];
+ Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(floatSpan), value);
+ if (!BitConverter.IsLittleEndian)
+ {
+ floatSpan.Reverse();
+ }
+
+ WriteRawByte(ref buffer, ref state, floatSpan[0]);
+ WriteRawByte(ref buffer, ref state, floatSpan[1]);
+ WriteRawByte(ref buffer, ref state, floatSpan[2]);
+ WriteRawByte(ref buffer, ref state, floatSpan[3]);
+ }
+
+ ///
+ /// Writes a uint64 field value, without a tag, to the stream.
+ ///
+ public static void WriteUInt64(ref Span buffer, ref WriterInternalState state, ulong value)
+ {
+ WriteRawVarint64(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an int64 field value, without a tag, to the stream.
+ ///
+ public static void WriteInt64(ref Span buffer, ref WriterInternalState state, long value)
+ {
+ WriteRawVarint64(ref buffer, ref state, (ulong)value);
+ }
+
+ ///
+ /// Writes an int32 field value, without a tag, to the stream.
+ ///
+ public static void WriteInt32(ref Span buffer, ref WriterInternalState state, int value)
+ {
+ if (value >= 0)
+ {
+ WriteRawVarint32(ref buffer, ref state, (uint)value);
+ }
+ else
+ {
+ // Must sign-extend.
+ WriteRawVarint64(ref buffer, ref state, (ulong)value);
+ }
+ }
+
+ ///
+ /// Writes a fixed64 field value, without a tag, to the stream.
+ ///
+ public static void WriteFixed64(ref Span buffer, ref WriterInternalState state, ulong value)
+ {
+ WriteRawLittleEndian64(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a fixed32 field value, without a tag, to the stream.
+ ///
+ public static void WriteFixed32(ref Span buffer, ref WriterInternalState state, uint value)
+ {
+ WriteRawLittleEndian32(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes a bool field value, without a tag, to the stream.
+ ///
+ public static void WriteBool(ref Span buffer, ref WriterInternalState state, bool value)
+ {
+ WriteRawByte(ref buffer, ref state, value ? (byte)1 : (byte)0);
+ }
+
+ ///
+ /// Writes a string field value, without a tag, to the stream.
+ /// The data is length-prefixed.
+ ///
+ public static void WriteString(ref Span buffer, ref WriterInternalState state, string value)
+ {
+ // Optimise the case where we have enough space to write
+ // the string directly to the buffer, which should be common.
+ int length = Utf8Encoding.GetByteCount(value);
+ WriteLength(ref buffer, ref state, length);
+ if (buffer.Length - state.position >= length)
+ {
+ if (length == value.Length) // Must be all ASCII...
+ {
+ for (int i = 0; i < length; i++)
+ {
+ buffer[state.position + i] = (byte)value[i];
+ }
+ state.position += length;
+ }
+ else
+ {
+#if NETSTANDARD1_1
+ // slowpath when Encoding.GetBytes(Char*, Int32, Byte*, Int32) is not available
+ byte[] bytes = Utf8Encoding.GetBytes(value);
+ WriteRawBytes(ref buffer, ref state, bytes);
+#else
+ ReadOnlySpan source = value.AsSpan();
+ int bytesUsed;
+ unsafe
+ {
+ fixed (char* sourceChars = &MemoryMarshal.GetReference(source))
+ fixed (byte* destinationBytes = &MemoryMarshal.GetReference(buffer.Slice(state.position)))
+ {
+ bytesUsed = Utf8Encoding.GetBytes(sourceChars, source.Length, destinationBytes, buffer.Length);
+ }
+ }
+ state.position += bytesUsed;
+#endif
+ }
+ }
+ else
+ {
+ // Opportunity for future optimization:
+ // Large strings that don't fit into the current buffer segment
+ // can probably be optimized by using Utf8Encoding.GetEncoder()
+ // but more benchmarks would need to be added as evidence.
+ byte[] bytes = Utf8Encoding.GetBytes(value);
+ WriteRawBytes(ref buffer, ref state, bytes);
+ }
+ }
+
+ ///
+ /// Write a byte string, without a tag, to the stream.
+ /// The data is length-prefixed.
+ ///
+ public static void WriteBytes(ref Span buffer, ref WriterInternalState state, ByteString value)
+ {
+ WriteLength(ref buffer, ref state, value.Length);
+ WriteRawBytes(ref buffer, ref state, value.Span);
+ }
+
+ ///
+ /// Writes a uint32 value, without a tag, to the stream.
+ ///
+ public static void WriteUInt32(ref Span buffer, ref WriterInternalState state, uint value)
+ {
+ WriteRawVarint32(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an enum value, without a tag, to the stream.
+ ///
+ public static void WriteEnum(ref Span buffer, ref WriterInternalState state, int value)
+ {
+ WriteInt32(ref buffer, ref state, value);
+ }
+
+ ///
+ /// Writes an sfixed32 value, without a tag, to the stream.
+ ///
+ public static void WriteSFixed32(ref Span buffer, ref WriterInternalState state, int value)
+ {
+ WriteRawLittleEndian32(ref buffer, ref state, (uint)value);
+ }
+
+ ///
+ /// Writes an sfixed64 value, without a tag, to the stream.
+ ///
+ public static void WriteSFixed64(ref Span buffer, ref WriterInternalState state, long value)
+ {
+ WriteRawLittleEndian64(ref buffer, ref state, (ulong)value);
+ }
+
+ ///
+ /// Writes an sint32 value, without a tag, to the stream.
+ ///
+ public static void WriteSInt32(ref Span buffer, ref WriterInternalState state, int value)
+ {
+ WriteRawVarint32(ref buffer, ref state, EncodeZigZag32(value));
+ }
+
+ ///
+ /// Writes an sint64 value, without a tag, to the stream.
+ ///
+ public static void WriteSInt64(ref Span buffer, ref WriterInternalState state, long value)
+ {
+ WriteRawVarint64(ref buffer, ref state, EncodeZigZag64(value));
+ }
+
+ ///
+ /// Writes a length (in bytes) for length-delimited data.
+ ///
+ ///
+ /// This method simply writes a rawint, but exists for clarity in calling code.
+ ///
+ public static void WriteLength(ref Span buffer, ref WriterInternalState state, int length)
+ {
+ WriteRawVarint32(ref buffer, ref state, (uint)length);
+ }
+
+ #endregion
+
+ #region Writing primitives
+ ///
+ /// Writes a 32 bit value as a varint. The fast route is taken when
+ /// there's enough buffer space left to whizz through without checking
+ /// for each byte; otherwise, we resort to calling WriteRawByte each time.
+ ///
+ public static void WriteRawVarint32(ref Span buffer, ref WriterInternalState state, uint value)
+ {
+ // Optimize for the common case of a single byte value
+ if (value < 128 && state.position < buffer.Length)
+ {
+ buffer[state.position++] = (byte)value;
+ return;
+ }
+
+ // Fast path when capacity is available
+ while (state.position < buffer.Length)
+ {
+ if (value > 127)
+ {
+ buffer[state.position++] = (byte)((value & 0x7F) | 0x80);
+ value >>= 7;
+ }
+ else
+ {
+ buffer[state.position++] = (byte)value;
+ return;
+ }
+ }
+
+ while (value > 127)
+ {
+ WriteRawByte(ref buffer, ref state, (byte)((value & 0x7F) | 0x80));
+ value >>= 7;
+ }
+
+ WriteRawByte(ref buffer, ref state, (byte)value);
+ }
+
+ public static void WriteRawVarint64(ref Span buffer, ref WriterInternalState state, ulong value)
+ {
+ // Optimize for the common case of a single byte value
+ if (value < 128 && state.position < buffer.Length)
+ {
+ buffer[state.position++] = (byte)value;
+ return;
+ }
+
+ // Fast path when capacity is available
+ while (state.position < buffer.Length)
+ {
+ if (value > 127)
+ {
+ buffer[state.position++] = (byte)((value & 0x7F) | 0x80);
+ value >>= 7;
+ }
+ else
+ {
+ buffer[state.position++] = (byte)value;
+ return;
+ }
+ }
+
+ while (value > 127)
+ {
+ WriteRawByte(ref buffer, ref state, (byte)((value & 0x7F) | 0x80));
+ value >>= 7;
+ }
+
+ WriteRawByte(ref buffer, ref state, (byte)value);
+ }
+
+ public static void WriteRawLittleEndian32(ref Span buffer, ref WriterInternalState state, uint value)
+ {
+ const int length = sizeof(uint);
+ if (state.position + length > buffer.Length)
+ {
+ WriteRawLittleEndian32SlowPath(ref buffer, ref state, value);
+ }
+ else
+ {
+ BinaryPrimitives.WriteUInt32LittleEndian(buffer.Slice(state.position), value);
+ state.position += length;
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private static void WriteRawLittleEndian32SlowPath(ref Span buffer, ref WriterInternalState state, uint value)
+ {
+ WriteRawByte(ref buffer, ref state, (byte)value);
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 8));
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 16));
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 24));
+ }
+
+ public static void WriteRawLittleEndian64(ref Span buffer, ref WriterInternalState state, ulong value)
+ {
+ const int length = sizeof(ulong);
+ if (state.position + length > buffer.Length)
+ {
+ WriteRawLittleEndian64SlowPath(ref buffer, ref state, value);
+ }
+ else
+ {
+ // TODO(jtattermusch): According to the benchmarks, writing byte-by-byte is actually faster
+ // than using BinaryPrimitives.WriteUInt64LittleEndian.
+ // This is strange especially because WriteUInt32LittleEndian seems to be much faster
+ // in terms of throughput.
+ buffer[state.position++] = ((byte)value);
+ buffer[state.position++] = ((byte)(value >> 8));
+ buffer[state.position++] = ((byte)(value >> 16));
+ buffer[state.position++] = ((byte)(value >> 24));
+ buffer[state.position++] = ((byte)(value >> 32));
+ buffer[state.position++] = ((byte)(value >> 40));
+ buffer[state.position++] = ((byte)(value >> 48));
+ buffer[state.position++] = ((byte)(value >> 56));
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void WriteRawLittleEndian64SlowPath(ref Span buffer, ref WriterInternalState state, ulong value)
+ {
+ WriteRawByte(ref buffer, ref state, (byte)value);
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 8));
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 16));
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 24));
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 32));
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 40));
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 48));
+ WriteRawByte(ref buffer, ref state, (byte)(value >> 56));
+ }
+
+ private static void WriteRawByte(ref Span buffer, ref WriterInternalState state, byte value)
+ {
+ if (state.position == buffer.Length)
+ {
+ WriteBufferHelper.RefreshBuffer(ref buffer, ref state);
+ }
+
+ buffer[state.position++] = value;
+ }
+
+ ///
+ /// Writes out an array of bytes.
+ ///
+ public static void WriteRawBytes(ref Span buffer, ref WriterInternalState state, byte[] value)
+ {
+ WriteRawBytes(ref buffer, ref state, new ReadOnlySpan(value));
+ }
+
+ ///
+ /// Writes out part of an array of bytes.
+ ///
+ public static void WriteRawBytes(ref Span buffer, ref WriterInternalState state, byte[] value, int offset, int length)
+ {
+ WriteRawBytes(ref buffer, ref state, new ReadOnlySpan(value, offset, length));
+ }
+
+ ///
+ /// Writes out part of an array of bytes.
+ ///
+ public static void WriteRawBytes(ref Span buffer, ref WriterInternalState state, ReadOnlySpan value)
+ {
+ if (buffer.Length - state.position >= value.Length)
+ {
+ // We have room in the current buffer.
+ value.CopyTo(buffer.Slice(state.position, value.Length));
+ state.position += value.Length;
+ }
+ else
+ {
+ // When writing to a CodedOutputStream backed by a Stream, we could avoid
+ // copying the data twice (first copying to the current buffer and
+ // and later writing from the current buffer to the underlying Stream)
+ // in some circumstances by writing the data directly to the underlying Stream.
+ // Current this is not being done to avoid specialcasing the code for
+ // CodedOutputStream vs IBufferWriter.
+ int bytesWritten = 0;
+ while (buffer.Length - state.position < value.Length - bytesWritten)
+ {
+ int length = buffer.Length - state.position;
+ value.Slice(bytesWritten, length).CopyTo(buffer.Slice(state.position, length));
+ bytesWritten += length;
+ state.position += length;
+ WriteBufferHelper.RefreshBuffer(ref buffer, ref state);
+ }
+
+ // copy the remaining data
+ int remainderLength = value.Length - bytesWritten;
+ value.Slice(bytesWritten, remainderLength).CopyTo(buffer.Slice(state.position, remainderLength));
+ state.position += remainderLength;
+ }
+ }
+ #endregion
+
+ #region Raw tag writing
+ ///
+ /// Encodes and writes a tag.
+ ///
+ public static void WriteTag(ref Span buffer, ref WriterInternalState state, int fieldNumber, WireFormat.WireType type)
+ {
+ WriteRawVarint32(ref buffer, ref state, WireFormat.MakeTag(fieldNumber, type));
+ }
+
+ ///
+ /// Writes an already-encoded tag.
+ ///
+ public static void WriteTag(ref Span buffer, ref WriterInternalState state, uint tag)
+ {
+ WriteRawVarint32(ref buffer, ref state, tag);
+ }
+
+ ///
+ /// Writes the given single-byte tag directly to the stream.
+ ///
+ public static void WriteRawTag(ref Span buffer, ref WriterInternalState state, byte b1)
+ {
+ WriteRawByte(ref buffer, ref state, b1);
+ }
+
+ ///
+ /// Writes the given two-byte tag directly to the stream.
+ ///
+ public static void WriteRawTag(ref Span buffer, ref WriterInternalState state, byte b1, byte b2)
+ {
+ if (state.position + 2 > buffer.Length)
+ {
+ WriteRawTagSlowPath(ref buffer, ref state, b1, b2);
+ }
+ else
+ {
+ buffer[state.position++] = b1;
+ buffer[state.position++] = b2;
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private static void WriteRawTagSlowPath(ref Span buffer, ref WriterInternalState state, byte b1, byte b2)
+ {
+ WriteRawByte(ref buffer, ref state, b1);
+ WriteRawByte(ref buffer, ref state, b2);
+ }
+
+ ///
+ /// Writes the given three-byte tag directly to the stream.
+ ///
+ public static void WriteRawTag(ref Span buffer, ref WriterInternalState state, byte b1, byte b2, byte b3)
+ {
+ if (state.position + 3 > buffer.Length)
+ {
+ WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3);
+ }
+ else
+ {
+ buffer[state.position++] = b1;
+ buffer[state.position++] = b2;
+ buffer[state.position++] = b3;
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private static void WriteRawTagSlowPath(ref Span buffer, ref WriterInternalState state, byte b1, byte b2, byte b3)
+ {
+ WriteRawByte(ref buffer, ref state, b1);
+ WriteRawByte(ref buffer, ref state, b2);
+ WriteRawByte(ref buffer, ref state, b3);
+ }
+
+ ///
+ /// Writes the given four-byte tag directly to the stream.
+ ///
+ public static void WriteRawTag(ref Span buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4)
+ {
+ if (state.position + 4 > buffer.Length)
+ {
+ WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3, b4);
+ }
+ else
+ {
+ buffer[state.position++] = b1;
+ buffer[state.position++] = b2;
+ buffer[state.position++] = b3;
+ buffer[state.position++] = b4;
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+
+ private static void WriteRawTagSlowPath(ref Span buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4)
+ {
+ WriteRawByte(ref buffer, ref state, b1);
+ WriteRawByte(ref buffer, ref state, b2);
+ WriteRawByte(ref buffer, ref state, b3);
+ WriteRawByte(ref buffer, ref state, b4);
+ }
+
+ ///
+ /// Writes the given five-byte tag directly to the stream.
+ ///
+ public static void WriteRawTag(ref Span buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4, byte b5)
+ {
+ if (state.position + 5 > buffer.Length)
+ {
+ WriteRawTagSlowPath(ref buffer, ref state, b1, b2, b3, b4, b5);
+ }
+ else
+ {
+ buffer[state.position++] = b1;
+ buffer[state.position++] = b2;
+ buffer[state.position++] = b3;
+ buffer[state.position++] = b4;
+ buffer[state.position++] = b5;
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ private static void WriteRawTagSlowPath(ref Span buffer, ref WriterInternalState state, byte b1, byte b2, byte b3, byte b4, byte b5)
+ {
+ WriteRawByte(ref buffer, ref state, b1);
+ WriteRawByte(ref buffer, ref state, b2);
+ WriteRawByte(ref buffer, ref state, b3);
+ WriteRawByte(ref buffer, ref state, b4);
+ WriteRawByte(ref buffer, ref state, b5);
+ }
+ #endregion
+
+ ///
+ /// Encode a 32-bit value with ZigZag encoding.
+ ///
+ ///
+ /// ZigZag encodes signed integers into values that can be efficiently
+ /// encoded with varint. (Otherwise, negative values must be
+ /// sign-extended to 64 bits to be varint encoded, thus always taking
+ /// 10 bytes on the wire.)
+ ///
+ public static uint EncodeZigZag32(int n)
+ {
+ // Note: the right-shift must be arithmetic
+ return (uint)((n << 1) ^ (n >> 31));
+ }
+
+ ///
+ /// Encode a 64-bit value with ZigZag encoding.
+ ///
+ ///
+ /// ZigZag encodes signed integers into values that can be efficiently
+ /// encoded with varint. (Otherwise, negative values must be
+ /// sign-extended to 64 bits to be varint encoded, thus always taking
+ /// 10 bytes on the wire.)
+ ///
+ public static ulong EncodeZigZag64(long n)
+ {
+ return (ulong)((n << 1) ^ (n >> 63));
+ }
+ }
+}
\ No newline at end of file
diff --git a/csharp/src/Google.Protobuf/WritingPrimitivesMessages.cs b/csharp/src/Google.Protobuf/WritingPrimitivesMessages.cs
new file mode 100644
index 000000000000..cd2d4379154e
--- /dev/null
+++ b/csharp/src/Google.Protobuf/WritingPrimitivesMessages.cs
@@ -0,0 +1,112 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices.ComTypes;
+using System.Security;
+
+namespace Google.Protobuf
+{
+ ///
+ /// Writing messages / groups.
+ ///
+ [SecuritySafeCritical]
+ internal static class WritingPrimitivesMessages
+ {
+ ///
+ /// Writes a message, without a tag.
+ /// The data is length-prefixed.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static void WriteMessage(ref WriteContext ctx, IMessage value)
+ {
+ WritingPrimitives.WriteLength(ref ctx.buffer, ref ctx.state, value.CalculateSize());
+ WriteRawMessage(ref ctx, value);
+ }
+
+ ///
+ /// Writes a group, without a tag.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static void WriteGroup(ref WriteContext ctx, IMessage value)
+ {
+ WriteRawMessage(ref ctx, value);
+ }
+
+ ///
+ /// Writes a message, without a tag.
+ /// Message will be written without a length prefix.
+ ///
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ public static void WriteRawMessage(ref WriteContext ctx, IMessage message)
+ {
+ if (message is IBufferMessage bufferMessage)
+ {
+ bufferMessage.InternalWriteTo(ref ctx);
+ }
+ else
+ {
+ // If we reached here, it means we've ran into a nested message with older generated code
+ // which doesn't provide the InternalWriteTo method that takes a WriteContext.
+ // With a slight performance overhead, we can still serialize this message just fine,
+ // but we need to find the original CodedOutputStream instance that initiated this
+ // serialization process and make sure its internal state is up to date.
+ // Note that this performance overhead is not very high (basically copying contents of a struct)
+ // and it will only be incurred in case the application mixes older and newer generated code.
+ // Regenerating the code from .proto files will remove this overhead because it will
+ // generate the InternalWriteTo method we need.
+
+ if (ctx.state.CodedOutputStream == null)
+ {
+ // This can only happen when the serialization started without providing a CodedOutputStream instance
+ // (e.g. WriteContext was created directly from a IBufferWriter).
+ // That also means that one of the new parsing APIs was used at the top level
+ // and in such case it is reasonable to require that all the nested message provide
+ // up-to-date generated code with WriteContext support (and fail otherwise).
+ throw new InvalidProtocolBufferException($"Message {message.GetType().Name} doesn't provide the generated method that enables WriteContext-based serialization. You might need to regenerate the generated protobuf code.");
+ }
+
+ ctx.CopyStateTo(ctx.state.CodedOutputStream);
+ try
+ {
+ // fallback parse using the CodedOutputStream that started current serialization tree
+ message.WriteTo(ctx.state.CodedOutputStream);
+ }
+ finally
+ {
+ ctx.LoadStateFrom(ctx.state.CodedOutputStream);
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.cc b/src/google/protobuf/compiler/csharp/csharp_field_base.cc
index 7d00402bca8f..b824c92f0200 100644
--- a/src/google/protobuf/compiler/csharp/csharp_field_base.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_field_base.cc
@@ -167,6 +167,12 @@ void FieldGeneratorBase::GenerateParsingCode(io::Printer* printer, bool use_pars
GenerateParsingCode(printer);
}
+void FieldGeneratorBase::GenerateSerializationCode(io::Printer* printer, bool use_write_context) {
+ // for some field types the value of "use_write_context" doesn't matter,
+ // so we fallback to the default implementation.
+ GenerateSerializationCode(printer);
+}
+
void FieldGeneratorBase::AddDeprecatedFlag(io::Printer* printer) {
if (descriptor_->options().deprecated()) {
printer->Print("[global::System.ObsoleteAttribute]\n");
diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.h b/src/google/protobuf/compiler/csharp/csharp_field_base.h
index 022ba2156598..d22a4b6cbb66 100644
--- a/src/google/protobuf/compiler/csharp/csharp_field_base.h
+++ b/src/google/protobuf/compiler/csharp/csharp_field_base.h
@@ -63,6 +63,7 @@ class FieldGeneratorBase : public SourceGeneratorBase {
virtual void GenerateParsingCode(io::Printer* printer) = 0;
virtual void GenerateParsingCode(io::Printer* printer, bool use_parse_context);
virtual void GenerateSerializationCode(io::Printer* printer) = 0;
+ virtual void GenerateSerializationCode(io::Printer* printer, bool use_write_context);
virtual void GenerateSerializedSizeCode(io::Printer* printer) = 0;
virtual void WriteHash(io::Printer* printer) = 0;
diff --git a/src/google/protobuf/compiler/csharp/csharp_map_field.cc b/src/google/protobuf/compiler/csharp/csharp_map_field.cc
index 472aba63ed0f..44c13e2f637a 100644
--- a/src/google/protobuf/compiler/csharp/csharp_map_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_map_field.cc
@@ -106,9 +106,15 @@ void MapFieldGenerator::GenerateParsingCode(io::Printer* printer, bool use_parse
}
void MapFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
+ GenerateSerializationCode(printer, true);
+}
+
+void MapFieldGenerator::GenerateSerializationCode(io::Printer* printer, bool use_write_context) {
printer->Print(
variables_,
- "$name$_.WriteTo(output, _map_$name$_codec);\n");
+ use_write_context
+ ? "$name$_.WriteTo(ref output, _map_$name$_codec);\n"
+ : "$name$_.WriteTo(output, _map_$name$_codec);\n");
}
void MapFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
diff --git a/src/google/protobuf/compiler/csharp/csharp_map_field.h b/src/google/protobuf/compiler/csharp/csharp_map_field.h
index 5054c94cc5a0..54156ecf5408 100644
--- a/src/google/protobuf/compiler/csharp/csharp_map_field.h
+++ b/src/google/protobuf/compiler/csharp/csharp_map_field.h
@@ -58,6 +58,7 @@ class MapFieldGenerator : public FieldGeneratorBase {
virtual void GenerateParsingCode(io::Printer* printer);
virtual void GenerateParsingCode(io::Printer* printer, bool use_parse_context);
virtual void GenerateSerializationCode(io::Printer* printer);
+ virtual void GenerateSerializationCode(io::Printer* printer, bool use_write_context);
virtual void GenerateSerializedSizeCode(io::Printer* printer);
virtual void WriteHash(io::Printer* printer);
diff --git a/src/google/protobuf/compiler/csharp/csharp_message.cc b/src/google/protobuf/compiler/csharp/csharp_message.cc
index e742fc984b37..d5d2b670cda7 100644
--- a/src/google/protobuf/compiler/csharp/csharp_message.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_message.cc
@@ -520,34 +520,26 @@ void MessageGenerator::GenerateMessageSerializationMethods(io::Printer* printer)
WriteGeneratedCodeAttributes(printer);
printer->Print(
"public void WriteTo(pb::CodedOutputStream output) {\n");
+ printer->Print("#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE\n");
printer->Indent();
+ printer->Print("output.WriteRawMessage(this);\n");
+ printer->Outdent();
+ printer->Print("#else\n");
+ printer->Indent();
+ GenerateWriteToBody(printer, false);
+ printer->Outdent();
+ printer->Print("#endif\n");
+ printer->Print("}\n\n");
- // Serialize all the fields
- for (int i = 0; i < fields_by_number().size(); i++) {
- std::unique_ptr generator(
- CreateFieldGeneratorInternal(fields_by_number()[i]));
- generator->GenerateSerializationCode(printer);
- }
-
- if (has_extension_ranges_) {
- // Serialize extensions
- printer->Print(
- "if (_extensions != null) {\n"
- " _extensions.WriteTo(output);\n"
- "}\n");
- }
-
- // Serialize unknown fields
- printer->Print(
- "if (_unknownFields != null) {\n"
- " _unknownFields.WriteTo(output);\n"
- "}\n");
-
- // TODO(jonskeet): Memoize size of frozen messages?
+ printer->Print("#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE\n");
+ WriteGeneratedCodeAttributes(printer);
+ printer->Print("void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {\n");
+ printer->Indent();
+ GenerateWriteToBody(printer, true);
printer->Outdent();
- printer->Print(
- "}\n"
- "\n");
+ printer->Print("}\n");
+ printer->Print("#endif\n\n");
+
WriteGeneratedCodeAttributes(printer);
printer->Print(
"public int CalculateSize() {\n");
@@ -576,6 +568,39 @@ void MessageGenerator::GenerateMessageSerializationMethods(io::Printer* printer)
printer->Print("}\n\n");
}
+void MessageGenerator::GenerateWriteToBody(io::Printer* printer, bool use_write_context) {
+ // Serialize all the fields
+ for (int i = 0; i < fields_by_number().size(); i++) {
+ std::unique_ptr generator(
+ CreateFieldGeneratorInternal(fields_by_number()[i]));
+ generator->GenerateSerializationCode(printer, use_write_context);
+ }
+
+ if (has_extension_ranges_) {
+ // Serialize extensions
+ printer->Print(
+ use_write_context
+ ? "if (_extensions != null) {\n"
+ " _extensions.WriteTo(ref output);\n"
+ "}\n"
+ : "if (_extensions != null) {\n"
+ " _extensions.WriteTo(output);\n"
+ "}\n");
+ }
+
+ // Serialize unknown fields
+ printer->Print(
+ use_write_context
+ ? "if (_unknownFields != null) {\n"
+ " _unknownFields.WriteTo(ref output);\n"
+ "}\n"
+ : "if (_unknownFields != null) {\n"
+ " _unknownFields.WriteTo(output);\n"
+ "}\n");
+
+ // TODO(jonskeet): Memoize size of frozen messages?
+}
+
void MessageGenerator::GenerateMergingMethods(io::Printer* printer) {
// Note: These are separate from GenerateMessageSerializationMethods()
// because they need to be generated even for messages that are optimized
diff --git a/src/google/protobuf/compiler/csharp/csharp_message.h b/src/google/protobuf/compiler/csharp/csharp_message.h
index dde85e039458..d02767e44b48 100644
--- a/src/google/protobuf/compiler/csharp/csharp_message.h
+++ b/src/google/protobuf/compiler/csharp/csharp_message.h
@@ -66,6 +66,7 @@ class MessageGenerator : public SourceGeneratorBase {
bool has_extension_ranges_;
void GenerateMessageSerializationMethods(io::Printer* printer);
+ void GenerateWriteToBody(io::Printer* printer, bool use_write_context);
void GenerateMergingMethods(io::Printer* printer);
void GenerateMainParseLoop(io::Printer* printer, bool use_parse_context);
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc b/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
index 402e44c2782a..04bc7bbb1bd2 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.cc
@@ -90,9 +90,15 @@ void RepeatedEnumFieldGenerator::GenerateParsingCode(io::Printer* printer, bool
}
void RepeatedEnumFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
+ GenerateSerializationCode(printer, true);
+}
+
+void RepeatedEnumFieldGenerator::GenerateSerializationCode(io::Printer* printer, bool use_write_context) {
printer->Print(
variables_,
- "$name$_.WriteTo(output, _repeated_$name$_codec);\n");
+ use_write_context
+ ? "$name$_.WriteTo(ref output, _repeated_$name$_codec);\n"
+ : "$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedEnumFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h b/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h
index 4ce13e646d0c..9b9ebd48facd 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_enum_field.h
@@ -61,6 +61,7 @@ class RepeatedEnumFieldGenerator : public FieldGeneratorBase {
virtual void GenerateParsingCode(io::Printer* printer);
virtual void GenerateParsingCode(io::Printer* printer, bool use_parse_context);
virtual void GenerateSerializationCode(io::Printer* printer);
+ virtual void GenerateSerializationCode(io::Printer* printer, bool use_write_context);
virtual void GenerateSerializedSizeCode(io::Printer* printer);
virtual void GenerateExtensionCode(io::Printer* printer);
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc b/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
index 448374096285..8a93cd13cfca 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
@@ -105,9 +105,15 @@ void RepeatedMessageFieldGenerator::GenerateParsingCode(io::Printer* printer, bo
}
void RepeatedMessageFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
+ GenerateSerializationCode(printer, true);
+}
+
+void RepeatedMessageFieldGenerator::GenerateSerializationCode(io::Printer* printer, bool use_write_context) {
printer->Print(
variables_,
- "$name$_.WriteTo(output, _repeated_$name$_codec);\n");
+ use_write_context
+ ? "$name$_.WriteTo(ref output, _repeated_$name$_codec);\n"
+ : "$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedMessageFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.h b/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.h
index 2cf33a475227..90441b82ef32 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.h
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.h
@@ -61,6 +61,7 @@ class RepeatedMessageFieldGenerator : public FieldGeneratorBase {
virtual void GenerateParsingCode(io::Printer* printer);
virtual void GenerateParsingCode(io::Printer* printer, bool use_parse_context);
virtual void GenerateSerializationCode(io::Printer* printer);
+ virtual void GenerateSerializationCode(io::Printer* printer, bool use_write_context);
virtual void GenerateSerializedSizeCode(io::Printer* printer);
virtual void GenerateExtensionCode(io::Printer* printer);
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc b/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
index 923121082657..0eacf91ce6ca 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
@@ -90,9 +90,15 @@ void RepeatedPrimitiveFieldGenerator::GenerateParsingCode(io::Printer* printer,
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
+ GenerateSerializationCode(printer, true);
+}
+
+void RepeatedPrimitiveFieldGenerator::GenerateSerializationCode(io::Printer* printer, bool use_write_context) {
printer->Print(
variables_,
- "$name$_.WriteTo(output, _repeated_$name$_codec);\n");
+ use_write_context
+ ? "$name$_.WriteTo(ref output, _repeated_$name$_codec);\n"
+ : "$name$_.WriteTo(output, _repeated_$name$_codec);\n");
}
void RepeatedPrimitiveFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h b/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h
index 58db62d01c67..23e77a9a2eaa 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h
@@ -57,6 +57,7 @@ class RepeatedPrimitiveFieldGenerator : public FieldGeneratorBase {
virtual void GenerateParsingCode(io::Printer* printer);
virtual void GenerateParsingCode(io::Printer* printer, bool use_parse_context);
virtual void GenerateSerializationCode(io::Printer* printer);
+ virtual void GenerateSerializationCode(io::Printer* printer, bool use_write_context);
virtual void GenerateSerializedSizeCode(io::Printer* printer);
virtual void GenerateExtensionCode(io::Printer* printer);
diff --git a/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc b/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc
index 24381dd23344..578f54ba697e 100644
--- a/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc
@@ -132,11 +132,19 @@ void WrapperFieldGenerator::GenerateParsingCode(io::Printer* printer, bool use_p
}
void WrapperFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
+ GenerateSerializationCode(printer, true);
+}
+
+void WrapperFieldGenerator::GenerateSerializationCode(io::Printer* printer, bool use_write_context) {
printer->Print(
variables_,
- "if ($has_property_check$) {\n"
- " _single_$name$_codec.WriteTagAndValue(output, $property_name$);\n"
- "}\n");
+ use_write_context
+ ? "if ($has_property_check$) {\n"
+ " _single_$name$_codec.WriteTagAndValue(ref output, $property_name$);\n"
+ "}\n"
+ : "if ($has_property_check$) {\n"
+ " _single_$name$_codec.WriteTagAndValue(output, $property_name$);\n"
+ "}\n");
}
void WrapperFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
@@ -269,12 +277,20 @@ void WrapperOneofFieldGenerator::GenerateParsingCode(io::Printer* printer, bool
}
void WrapperOneofFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
+ GenerateSerializationCode(printer, true);
+}
+
+void WrapperOneofFieldGenerator::GenerateSerializationCode(io::Printer* printer, bool use_write_context) {
// TODO: I suspect this is wrong...
printer->Print(
variables_,
- "if ($has_property_check$) {\n"
- " _oneof_$name$_codec.WriteTagAndValue(output, ($type_name$) $oneof_name$_);\n"
- "}\n");
+ use_write_context
+ ? "if ($has_property_check$) {\n"
+ " _oneof_$name$_codec.WriteTagAndValue(ref output, ($type_name$) $oneof_name$_);\n"
+ "}\n"
+ : "if ($has_property_check$) {\n"
+ " _oneof_$name$_codec.WriteTagAndValue(output, ($type_name$) $oneof_name$_);\n"
+ "}\n");
}
void WrapperOneofFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
diff --git a/src/google/protobuf/compiler/csharp/csharp_wrapper_field.h b/src/google/protobuf/compiler/csharp/csharp_wrapper_field.h
index 438080d5b9cd..e9bd043f2276 100644
--- a/src/google/protobuf/compiler/csharp/csharp_wrapper_field.h
+++ b/src/google/protobuf/compiler/csharp/csharp_wrapper_field.h
@@ -60,6 +60,7 @@ class WrapperFieldGenerator : public FieldGeneratorBase {
virtual void GenerateParsingCode(io::Printer* printer);
virtual void GenerateParsingCode(io::Printer* printer, bool use_parse_context);
virtual void GenerateSerializationCode(io::Printer* printer);
+ virtual void GenerateSerializationCode(io::Printer* printer, bool use_write_context);
virtual void GenerateSerializedSizeCode(io::Printer* printer);
virtual void GenerateExtensionCode(io::Printer* printer);
@@ -86,6 +87,7 @@ class WrapperOneofFieldGenerator : public WrapperFieldGenerator {
virtual void GenerateParsingCode(io::Printer* printer);
virtual void GenerateParsingCode(io::Printer* printer, bool use_parse_context);
virtual void GenerateSerializationCode(io::Printer* printer);
+ virtual void GenerateSerializationCode(io::Printer* printer, bool use_write_context);
virtual void GenerateSerializedSizeCode(io::Printer* printer);
};